Got python and shell interface conversions to work for new syntax

Author: tclose

example-specs/pkg-gen/qsmxt.yaml

@@ -0,0 +1,48 @@
+qsmxt:
+  interfaces:
+  - qsmxt.interfaces.nipype_interface_addtojson.AddToJsonInterface
+  - qsmxt.interfaces.nipype_interface_analyse.AnalyseInterface
+  - qsmxt.interfaces.nipype_interface_axialsampling.AxialSamplingInterface
+  - qsmxt.interfaces.nipype_interface_axialsampling.ResampleLikeInterface
+  - qsmxt.interfaces.nipype_interface_bet2.Bet2Interface
+  - qsmxt.interfaces.nipype_interface_clearswi.ClearSwiInterface
+  - qsmxt.interfaces.nipype_interface_combinemagnitude.CombineMagnitudeInterface
+  - qsmxt.interfaces.nipype_interface_copyfile.DynamicCopyFiles
+  - qsmxt.interfaces.nipype_interface_erode.ErosionInterface
+  - qsmxt.interfaces.nipype_interface_fastsurfer.FastSurferInterface
+  - qsmxt.interfaces.nipype_interface_hdbet.HDBETInterface
+  - qsmxt.interfaces.nipype_interface_json.JsonInterface
+  - qsmxt.interfaces.nipype_interface_laplacian_unwrapping.LaplacianInterface
+  - qsmxt.interfaces.nipype_interface_makehomogeneous.MakeHomogeneousInterface
+  - qsmxt.interfaces.nipype_interface_masking.MaskingInterface
+  - qsmxt.interfaces.nipype_interface_mgz2nii.Mgz2NiiInterface
+  - qsmxt.interfaces.nipype_interface_nextqsm.NextqsmInterface
+  - qsmxt.interfaces.nipype_interface_nextqsm.NormalizeB0Interface
+  - qsmxt.interfaces.nipype_interface_nii2dcm.Nii2DcmInterface
+  - qsmxt.interfaces.nipype_interface_nonzeroaverage.NonzeroAverageInterface
+  - qsmxt.interfaces.nipype_interface_phaseweights.RomeoMaskingInterface
+  - qsmxt.interfaces.nipype_interface_phaseweights.PbMaskingInterface
+  - qsmxt.interfaces.nipype_interface_processphase.ScalePhaseInterface
+  - qsmxt.interfaces.nipype_interface_processphase.PhaseToNormalizedInterface
+  - qsmxt.interfaces.nipype_interface_processphase.FreqToPhaseInterface
+  - qsmxt.interfaces.nipype_interface_processphase.FreqToNormalizedInterface  
+  - qsmxt.interfaces.nipype_interface_qsm_referencing.ReferenceQSMInterface
+  - qsmxt.interfaces.nipype_interface_qsmjl.LaplacianUnwrappingInterface
+  - qsmxt.interfaces.nipype_interface_qsmjl.PhaseToFreqInterface
+  - qsmxt.interfaces.nipype_interface_qsmjl.VsharpInterface
+  - qsmxt.interfaces.nipype_interface_qsmjl.PdfInterface
+  - qsmxt.interfaces.nipype_interface_qsmjl.RtsQsmInterface
+  - qsmxt.interfaces.nipype_interface_qsmjl.TvQsmInterface
+  - qsmxt.interfaces.nipype_interface_resample_like.ResampleLikeInterface
+  - qsmxt.interfaces.nipype_interface_romeo.RomeoB0Interface
+  - qsmxt.interfaces.nipype_interface_t2star_r2star.T2sR2sInterface
+  - qsmxt.interfaces.nipype_interface_tgv_qsm_jl.TGVQSMJlInterface
+  - qsmxt.interfaces.nipype_interface_tgv_qsm.TGVQSMInterface
+  - qsmxt.interfaces.nipype_interface_twopass.TwopassNiftiInterface
+  workflows:
+  - qsmxt.workflows.masking.masking_workflow
+  - qsmxt.workflows.qsm.get_preceding_node_and_attribute
+  - qsmxt.workflows.qsm.get_matching_files
+  - qsmxt.workflows.qsm.init_qsm_workflow
+  - qsmxt.workflows.qsm.qsm_workflow
+  - qsmxt.workflows.template.init_template_workflow

nipype2pydra/cli/convert.py

@@ -74,6 +74,7 @@ def convert(
             if fspath.parent == package_dir and fspath.name in (
                 "_version.py",
                 "__init__.py",
+                "ported",
             ):
                 continue
             if fspath.is_dir():

nipype2pydra/interface/python.py

@@ -12,6 +12,20 @@
 logger = logging.getLogger("nipype2pydra")
 
 
+def type2str(type_):
+    """Convert a type to a string representation."""
+    if isinstance(type_, str):
+        return type_
+    if type_ is ty.Any:
+        return "ty.Any"
+    elif hasattr(type_, "__name__"):
+        return type_.__name__
+    elif hasattr(type_, "__qualname__"):
+        return type_.__qualname__
+    else:
+        return str(type_).replace("typing.", "ty.")
+
+
 @attrs.define(slots=False)
 class PythonInterfaceConverter(BaseInterfaceConverter):
 
@@ -136,8 +150,8 @@ def generate_code(self, input_fields, nonstd_types, output_fields) -> ty.Tuple[
 
         assert method_body, "Neither `run_interface` and `list_outputs` are defined"
 
-        spec_str = "@python.define"
-        spec_str += f"class {self.task_name}(python.Task['{self.task_name}.Outputs']):"
+        spec_str = "@python.define\n"
+        spec_str += f"class {self.task_name}(python.Task['{self.task_name}.Outputs']):\n"
         spec_str += '    """\n'
         spec_str += self.create_doctests(
             input_fields=input_fields, nonstd_types=nonstd_types
@@ -147,32 +161,33 @@ def generate_code(self, input_fields, nonstd_types, output_fields) -> ty.Tuple[
         for inpt in input_fields:
             if len(inpt) == 4:
                 name, type_, default, _ = inpt
-                spec_str += f"    {name}: {type_} = {default}\n"
+                spec_str += f"    {name}: {type2str(type_)} = {default}\n"
             else:
                 name, type_, _ = inpt
-                spec_str += f"    {name}: {type_}\n"
+                spec_str += f"    {name}: {type2str(type_)}\n"
 
-        spec_str += "    @staticmethod\n"
+        spec_str += "\n\n    class Outputs(python.Outputs):\n"
+        for outpt in output_fields:
+            name, type_, _ = outpt
+            spec_str += f"        {name}: {type2str(type_)}\n"
+
+        spec_str += "\n    @staticmethod\n"
         spec_str += (
             "    def function("
-            + ", ".join(f"{n}: {t}" for n, t, _ in input_fields)
+            + ", ".join(f"{i[0]}: {type2str(i[1])}" for i in input_fields)
             + ")"
         )
-        output_types = [o[1] for o in output_fields]
+        output_types = [type2str(o[1]) for o in output_fields]
         if any(t is not ty.Any for t in output_types):
-            spec_str += "-> "
+            spec_str += " -> "
             if len(output_types) > 1:
                 spec_str += "tuples[" + ", ".join(output_types) + "]"
             else:
                 spec_str += output_types[0]
         spec_str += ":\n"
-        spec_str += method_body + "\n"
-        spec_str += "\n    return {}".format(", ".join(output_names))
+        spec_str += "    " + method_body.replace("\n", "\n    ") + "\n"
+        spec_str += "\n        return {}".format(", ".join(output_names))
 
-        spec_str += "    class Outputs(python.Outputs):"
-        for outpt in output_fields:
-            name, type_, _ = outpt
-            spec_str += f"        {name}: {type_}\n"
 
         for m in sorted(self.used.methods, key=attrgetter("__name__")):
             if m.__name__ not in self.included_methods:

nipype2pydra/interface/shell.py

@@ -86,14 +86,6 @@ def generate_code(self, input_fields, nonstd_types, output_fields) -> str:
                     "try the FunctionInterfaceConverter 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__
-
         nonstd_types = copy(nonstd_types)
 
         input_names = [i[0] for i in input_fields]
@@ -485,7 +477,7 @@ def callables_code(self):
                 )
                 lo_body = self._process_inputs(lo_body)
                 lo_body = re.sub(
-                    r"(\w+) = self\.output_spec\(\).get\(\)", r"\1 = {}", lo_body
+                    r"(\w+) = self\.output_spec\(\).(?:trait_)get\(\)", r"\1 = {}", lo_body
                 )
 
                 if not lo_body.strip():

nipype2pydra/package.py

@@ -660,7 +660,9 @@ def package_dir(self, package_root: Path) -> Path:
 
     def write_post_release_file(self, fspath: Path):
 
-        if ".dev" in self.nipype_package.__version__:
+        pkg_version = getattr(self.nipype_package, "__version__", "0.1.0")
+
+        if ".dev" in pkg_version:
             logger.warning(
                 (
                     "using development version of nipype2pydra (%s), "
@@ -680,7 +682,7 @@ def write_post_release_file(self, fspath: Path):
                 self.name,
             )
 
-        src_pkg_version = self.nipype_package.__version__.split(".dev")[0]
+        src_pkg_version = pkg_version.split(".dev")[0]
         nipype2pydra_version = nipype2pydra.__version__.split(".dev")[0]
         post_release = (src_pkg_version + nipype2pydra_version).replace(".", "")
 
@@ -874,7 +876,10 @@ def write_to_module(
         converter_imports = []
 
         for klass in used.classes:
-            if f"\nclass {klass.__name__}(" not in code_str:
+            if (
+                klass.__module__ == module_name
+                and f"\nclass {klass.__name__}(" not in code_str
+            ):
                 try:
                     class_converter = self.classes[full_address(klass)]
                     converter_imports.extend(class_converter.used.import_stmts)
@@ -906,7 +911,10 @@ def write_to_module(
                 code_str += "\n" + converted_code + "\n"
 
         for func in sorted(used.functions, key=attrgetter("__name__")):
-            if f"\ndef {func.__name__}(" not in code_str:
+            if (
+                func.__module__ == module_name
+                and f"\ndef {func.__name__}(" not in code_str
+            ):
                 if func.__name__ in self.functions:
                     function_converter = self.functions[full_address(func)]
                     converter_imports.extend(function_converter.used.import_stmts)

nipype2pydra/symbols.py

@@ -403,7 +403,8 @@ def _find_referenced(
                                 class_def = (obj.__name__, obj)
                                 if (
                                     class_def
-                                    not in self.imported_classes + omit_classes
+                                    not in self.imported_classes
+                                    + self.package.omit_classes
                                 ):
                                     self.imported_classes.append(class_def)
                                 intra_pkg_objs[imported.object.__name__].add(obj)