debugging running tests

example-specs/pkg-gen/niworkflows.yaml

@@ -5,6 +5,7 @@ niworkflows:
     - niworkflows.interfaces.bids.ReadSidecarJSON
     - niworkflows.interfaces.fixes.FixHeaderApplyTransforms
     - niworkflows.interfaces.fixes.FixN4BiasFieldCorrection
+    - niworkflows.interfaces.fixes.FixHeaderRegistration
     - niworkflows.interfaces.header.SanitizeImage
     - niworkflows.interfaces.images.RobustAverage
     - niworkflows.interfaces.morphology.BinaryDilation

nipype2pydra/cli/convert.py

@@ -66,10 +66,15 @@ def convert(
     # Clean previous version of output dir
     package_dir = converter.package_dir(package_root)
     if converter.interface_only:
-        shutil.rmtree(package_dir / "auto")
+        auto_dir = package_dir / "auto"
+        if auto_dir.exists():
+            shutil.rmtree(auto_dir)
     else:
         for fspath in package_dir.iterdir():
-            if fspath == package_dir / "__init__.py":
+            if fspath.parent == package_dir and fspath.name in (
+                "_version.py",
+                "__init__.py",
+            ):
                 continue
             if fspath.is_dir():
                 shutil.rmtree(fspath)

nipype2pydra/helpers.py

@@ -9,8 +9,8 @@
 from types import ModuleType
 import black.report
 import yaml
+from .symbols import UsedSymbols
 from .utils import (
-    UsedSymbols,
     extract_args,
     full_address,
     multiline_comment,
@@ -121,19 +121,15 @@ def nipype_object(self):
         return getattr(self.nipype_module, self.nipype_name)
 
     @cached_property
-    def used_symbols(self) -> UsedSymbols:
+    def used(self) -> UsedSymbols:
         used = UsedSymbols.find(
             self.nipype_module,
             [self.src],
+            package=self.package,
             collapse_intra_pkg=False,
-            omit_classes=self.package.omit_classes,
-            omit_modules=self.package.omit_modules,
-            omit_functions=self.package.omit_functions,
-            omit_constants=self.package.omit_constants,
             always_include=self.package.all_explicit,
-            translations=self.package.all_import_translations,
         )
-        used.imports.update(i.to_statement() for i in self.imports)
+        used.import_stmts.update(i.to_statement() for i in self.imports)
         return used
 
     @cached_property
@@ -147,12 +143,10 @@ def converted_code(self) -> ty.List[str]:
     @cached_property
     def nested_interfaces(self):
         potential_classes = {
-            full_address(c[1]): c[0]
-            for c in self.used_symbols.intra_pkg_classes
-            if c[0]
+            full_address(c[1]): c[0] for c in self.used.imported_classes if c[0]
         }
         potential_classes.update(
-            (full_address(c), c.__name__) for c in self.used_symbols.local_classes
+            (full_address(c), c.__name__) for c in self.used.classes
         )
         return {
             potential_classes[address]: workflow
@@ -350,6 +344,7 @@ def _converted_code(self) -> ty.Tuple[str, ty.List[str]]:
             # Write to file for debugging
             debug_file = "~/unparsable-nipype2pydra-output.py"
             with open(Path(debug_file).expanduser(), "w") as f:
+                f.write(f"# Attemping to convert {self.full_name}\n")
                 f.write(code_str)
             raise RuntimeError(
                 f"Black could not parse generated code (written to {debug_file}): "
@@ -378,8 +373,7 @@ class ClassConverter(BaseHelperConverter):
 
     @cached_property
     def _converted_code(self) -> ty.Tuple[str, ty.List[str]]:
-        """Convert the Nipype workflow function to a Pydra workflow function and determine
-        the configuration parameters that are used
+        """Convert a class into Pydra-
 
         Returns
         -------
@@ -390,18 +384,30 @@ def _converted_code(self) -> ty.Tuple[str, ty.List[str]]:
         """
 
         used_configs = set()
-        parts = re.split(
-            r"\n    (?!\s|\))", replace_undefined(self.src), flags=re.MULTILINE
-        )
+
+        src = replace_undefined(self.src)[len("class ") :]
+        name, bases, class_body = extract_args(src, drop_parens=True)
+        bases = [
+            b
+            for b in bases
+            if not self.package.is_omitted(getattr(self.nipype_module, b))
+        ]
+
+        parts = re.split(r"\n    (?!\s|\))", class_body, flags=re.MULTILINE)
         converted_parts = []
-        for part in parts:
+        for part in parts[1:]:
             if part.startswith("def"):
                 converted_func, func_used_configs = self._convert_function(part)
                 converted_parts.append(converted_func)
                 used_configs.update(func_used_configs)
             else:
                 converted_parts.append(part)
-        code_str = "\n    ".join(converted_parts)
+        code_str = (
+            f"class {name}("
+            + ", ".join(bases)
+            + "):\n    "
+            + "\n    ".join(converted_parts)
+        )
         # Format the the code before the find and replace so it is more predictable
         try:
             code_str = black.format_file_contents(
@@ -413,6 +419,7 @@ def _converted_code(self) -> ty.Tuple[str, ty.List[str]]:
             # Write to file for debugging
             debug_file = "~/unparsable-nipype2pydra-output.py"
             with open(Path(debug_file).expanduser(), "w") as f:
+                f.write(f"# Attemping to convert {self.full_name}\n")
                 f.write(code_str)
             raise RuntimeError(
                 f"Black could not parse generated code (written to {debug_file}): "