Merge pull request #3 from djarecka/converter_cli

Converter cli

Author: djarecka

README.md

@@ -24,43 +24,56 @@ pip install /path/to/pydra-fsl/
 `FSLConverter` class (from `tools/converter.py`) requires three parts of information:
 
 - Nipype spec: converter loads nipype interface and reads `_cmd`, `input_spec` and `output_spec`
-- yml file with additional spec: `specs/fsl_conv_params.yml` contains additional spec that are written based 
+- yml file with additional spec: `specs/fsl_{module_name}_params.yml` contains additional spec that are written based 
 on additional functions from nipype (including `list_outputs`), each interface can have the following fields:
-    - inputs_metadata: additional fields for metadata for fields from input_spec, 
-    e.g., used for `FAST` to set default for `number_classes` 
+    - inputs_metadata: additional metadata for fields from input_spec 
+    (it will be included in `metadata` in pydra spec), 
+    e.g., used in `specs/fsl_preprocess_params.yml` for `FAST` to set default value for `number_classes` 
     (it's not part of nipype's spec, but it's set in `list_output`)
 
-    - output_requirements: providing required field for the output to be created, 
+    - output_requirements: providing required fields for the output to be created, 
     taken from `list_output` structure; 
-    it's a part of the `requires` field in metadata
+    it's a part of the `requires` field in metadata in pydra spec
 
     - output_templates: providing template to create the output file name, 
     taken from `list_output` structure; 
     it is set as `output_file_template` in metadata
 
     - output_callables: providing function name that should be used to gather output,
     based on the `list_output` structure and used only for `FAST`;
-    it is set as `output_file_template` in metadata
+    it is set as `callable` in metadata
+    
+    - tests_inputs, tests_outputs: specification for tests, 
+    the fields should have the same length and each element should contain 
+    the input fields values and list of the expected output fields names
+    
+    - doctests: specification for doctest,
+    should include values for input fields and the expected `cmdline` 
 
 - python file with functions used as callables to gather the outputs: 
 `specs/callables.py` should contain all the functions from `output_callables`;
 the source code of the functions is read and written again in the pydra interface file
 
 
-### How to convert
+### How to use the convert
 
-Currently, the converter is temporarly used in a pytest test, so can be run as `pytest tools/converter.py`
-in order to run `test_convert_file` (other tests should be skipped).
-The tests will create a converter for interfaces names provided in the 
-`parametrize` decorator and for each interface `pydra_specs` will be run.
-The method creates file with the pydra task in the `preprocess` directory,
-and two tests in the `preprocess/tests` directory. 
+The converter can be used by running:
+ 
+    python tools/converter.py --interface_name <name of teh interface> --module_name <module_name>
+
+The pydra task will be created and saved in `pydra/tasks/fsl/{module_name}/{interface_name}.py`.
+Note, that the spec file has to be present for the specific module name in order to run the converter.
+If no `interface_name` is provided, the default value `all` will be used
+ and the converter will be run for all interfaces from the spec file.
 
 Tests are written based on the fields from the yml file: 
 `tests_inputs` and `tests_outputs` (the lengths should be the same).
 One test, `test_specs_*` checks only the correctness of the spec based
 on the `test_inputs/outputs` pairs, i.e. predicts which output fields
 should be created based on the list of the input fields.
-The second test, `test_run_*` should run teh interfaces, this is temporary, 
-should be removed from the final repo. 
+The second test, `test_run_*` should run the interfaces 
+(TODO: this is temporary, should be removed from the final repo). 
+Tests can be run using `pytest`:
+
+    pytest -vs pydra/tasks/fsl/{module_name}/tests
 

specs/fsl_conv_param.yml renamed to specs/fsl_preprocess_param.yml

@@ -2,14 +2,17 @@
 from nipype.interfaces.base import traits_extension
 from pydra.engine import specs
 
-import os, yaml, black, imp
+import os, sys, yaml, black, imp
 import traits
 from pathlib import Path
 import typing as ty
 import inspect
-import pytest
-
+import click
+import warnings
+import functools
 
+sys.path.append(str(Path(__file__).resolve().parent.parent / 'specs'))
+import callables
 
 class FSLConverter:
 
@@ -31,8 +34,7 @@ class FSLConverter:
                     ]
 
 
-    def __init__(self, interface_name,
-                 interface_spec_file=Path(os.path.dirname(__file__)) / "../specs/fsl_conv_param.yml"):
+    def __init__(self, interface_name, interface_spec_file):
         self.interface_name = interface_name
         with interface_spec_file.open() as f:
             self.interface_spec = yaml.safe_load(f)[self.interface_name]
@@ -348,7 +350,6 @@ def function_callables(self):
         python_functions_spec = Path(os.path.dirname(__file__)) / "../specs/callables.py"
         if not python_functions_spec.exists():
             raise Exception("specs/callables.py file is needed if output_callables in the spec files")
-        from specs import callables
         fun_str = ""
         fun_names = list(set(self.interface_spec["output_callables"].values()))
         fun_names.sort()
@@ -416,14 +417,55 @@ def string_formats(self, argstr, name):
         return argstr_new
 
 
-
-@pytest.mark.parametrize("interface_name",
-                         ["BET", "MCFLIRT", "FLIRT", "FNIRT", "ApplyWarp", "SliceTimer",
-                          "SUSAN", "PRELUDE", "FIRST", "FAST"]
-                         )
-def test_convert_file(interface_name):
-    converter = FSLConverter(interface_name=interface_name)
-
-    dirname_interf = Path(__file__).parent.parent / "pydra/tasks/fsl/preprocess"
-
-    input_spec, output_spec = converter.pydra_specs(write=True, dirname=dirname_interf)
+FSL_MODULES = ['aroma', 'dti', 'epi', 'fix', 'maths', 'model', 'possum', 'preprocess', 'utils']
+
+@click.command()
+@click.option("-i", "--interface_name", required=True, default="all",
+              help="name of the interface (name used in Nipype, e.g. BET) or all (default)"
+                   "if all is used all interfaces from the spec file will be created")
+@click.option("-m", "--module_name", required=True, help=f"name of the module from the list {FSL_MODULES}")
+def create_pydra_spec(interface_name, module_name):
+    if module_name not in FSL_MODULES:
+        raise Exception(f"module name {module_name} not available;"
+                        f"should be from the list {FSL_MODULES}")
+
+    spec_file = Path(os.path.dirname(__file__)) / f"../specs/fsl_{module_name}_param.yml"
+    if not spec_file.exists():
+        raise Exception(f"the specification file doesn't exist for the module {module_name},"
+                        f"create the specification file in {spec_file.parent}")
+
+    @functools.lru_cache()
+    def all_interfaces(module):
+        nipype_module = getattr(fsl, module)
+        all_specs = [el for el in dir(nipype_module) if "InputSpec" in el]
+        all_interf = [el.replace("InputSpec", "") for el in all_specs]
+
+        # interfaces in the spec file
+        with open(spec_file) as f:
+            spec_interf = yaml.safe_load(f).keys()
+
+        if set(all_interf) - set(spec_interf):
+            warnings.warn(f"some interfaces are not in the spec file: "
+                          f"{set(all_interf) - set(spec_interf)}, "
+                          f"and pydra interfaces will not be created for them")
+        return spec_interf
+
+    if interface_name == "all":
+        interface_list = all_interfaces(module_name)
+    elif interface_name in all_interfaces(module_name):
+        interface_list = [interface_name]
+    else:
+        raise Exception(f"interface_name has to be 'all' "
+                        f"or a name from the list {all_interfaces(module_name)}")
+
+    dirname_interf = Path(__file__).parent.parent / f"pydra/tasks/fsl/{module_name}"
+    dirname_interf.mkdir(exist_ok=True)
+
+    for interface_el in interface_list:
+        converter = FSLConverter(
+            interface_name=interface_el,
+            interface_spec_file=Path(__file__).parent.parent / "specs/fsl_preprocess_param.yml")
+        converter.pydra_specs(write=True, dirname=dirname_interf)
+
+if __name__ == '__main__':
+    create_pydra_spec()