fix type and indent errors for CI

Author: Vasu Jaganath

src/sophios/compiler.py

@@ -841,9 +841,14 @@ def compile_workflow_once(yaml_tree_ast: YamlTree,
         steps_list.append(step_i_copy)
     yaml_tree.update({'steps': steps_list})  # steps_list ?
 
+    # --------------------------------------------------------
+    # Helpers for generating yaml_inputs for workflow execution from inputs_workflow
+    # --------------------------------------------------------
     def type_includes_null(cwl_type: Any) -> bool:
         if isinstance(cwl_type, list):
             return "null" in cwl_type
+        if isinstance(cwl_type, str) and cwl_type.endswith("?"):
+            return True
         return False
 
     def strip_null_from_union(cwl_type: Any) -> Any:
@@ -852,99 +857,111 @@ def strip_null_from_union(cwl_type: Any) -> Any:
             if len(non_null) == 1:
                 return non_null[0]
             return non_null
+        if isinstance(cwl_type, str) and cwl_type.endswith("?"):
+            return cwl_type[:-1]
         return cwl_type
 
     def emit_file_or_dir(type_name: str, value: Any, fmt: Any = None) -> Dict[str, Any]:
-        obj = {
+        obj: Dict[str, Any] = {
             "class": type_name,
             "location": value
         }
         if type_name == "File" and fmt:
             obj["format"] = fmt
         return obj
 
-    def populate_scalar_val(in_dict: Dict[str, Any]) -> Any:
+    # --------------------------------------------------------
+    # Scalar emission for each primitive type, as well as File and Directory
+    # --------------------------------------------------------
+    def populate_scalar_val(cwl_type: Any, value: Any, fmt: Any = None) -> Any:
+        match cwl_type:
+            case "File":
+                obj: Dict[str, Any] = {
+                    "class": "File",
+                    "location": value
+                }
+                if fmt:
+                    obj["format"] = fmt
+                return obj
+
+            case "Directory":
+                return {
+                    "class": "Directory",
+                    "location": value
+                }
+
+            case "string":
+                return str(value)
+
+            case "int":
+                return int(value)
+
+            case "float":
+                return float(value)
+
+            case "boolean":
+                return bool(value)
+
+            case _:
+                # Unknown or already structured type
+                return value
+
+    # --------------------------------------------------------
+    # Main input handling for yaml_inputs
+    # --------------------------------------------------------
+    def populate_input_value(in_dict: Dict[str, Any]) -> Any:
         raw_type = in_dict["type"]
         value = in_dict.get("value")
         fmt = in_dict.get("format")
 
-        # Optional null handling is done outside this function
-        cwl_type = strip_null_from_union(raw_type)
-
-        # File
-        if cwl_type == "File":
-            return emit_file_or_dir("File", value, fmt)
-
-        # Directory
-        if cwl_type == "Directory":
-            return emit_file_or_dir("Directory", value)
-
-        # Primitive types
-        if cwl_type in ("string", "string?"):
-            return str(value)
-
-        if cwl_type in ("int", "int?"):
-            return int(value)
-
-        if cwl_type in ("float", "float?"):
-            return float(value)
-
-        if cwl_type in ("boolean", "boolean?"):
-            return bool(value)
+        # ---------- Null handling ----------
+        if value is None:
+            if type_includes_null(raw_type):
+                return None
+            raise ValueError(
+                f"Required input of type {raw_type} was not provided."
+            )
 
-        # Fallback for unknown types
-        return value
+        # Normalize type (strip null / ?)
+        cwl_type = strip_null_from_union(raw_type)
 
-    def populate_input_value(in_dict: Dict[str, Any]) -> Any:
-        raw_type = in_dict["type"]
-        value = in_dict.get("value")
+        # Normalize type
+        cwl_type = strip_null_from_union(raw_type)
 
-        # --- Handle optional null case ---
-        if value is None:
-            if type_includes_null(raw_type):
-                return None  # caller will omit key
-            else:
-                raise ValueError(
-                    f"Required input of type {raw_type} was not provided."
-                )
-
-        # --- Handle array types ---
-        # Case 1: {"type": "array", "items": ...}
-        if isinstance(raw_type, dict) and raw_type.get("type") == "array":
-            item_type = raw_type["items"]
+        # ---------- Array handling ----------
+        # Case: {"type": "array", "items": ...}
+        if isinstance(cwl_type, dict) and cwl_type.get("type") == "array":
+            item_type = strip_null_from_union(cwl_type["items"])
+            # wrap scalar into list if necessary for lenient shape handling
+            values = value if isinstance(value, list) else [value]
             return [
-                populate_scalar_val({
-                    "type": item_type,
-                    "value": val,
-                    "format": in_dict.get("format")
-                })
-                for val in value
+                populate_scalar_val(item_type, v, fmt)
+                for v in values
             ]
 
-        # Case 2: union including array
-        if isinstance(raw_type, list):
-            for t in raw_type:
+        # Case: union including array
+        if isinstance(cwl_type, list):
+            for t in cwl_type:
                 if isinstance(t, dict) and t.get("type") == "array":
-                    item_type = t["items"]
+                    item_type = strip_null_from_union(t["items"])
+                    # wrap scalar into list if necessary for lenient shape handling
+                    values = value if isinstance(value, list) else [value]
                     return [
-                        populate_scalar_val({
-                            "type": item_type,
-                            "value": val,
-                            "format": in_dict.get("format")
-                        })
-                        for val in value
+                        populate_scalar_val(item_type, v, fmt)
+                        for v in values
                     ]
 
-        # --- Scalar case ---
-        return populate_scalar_val(in_dict)
+        # ---------- Scalar case ----------
+        return populate_scalar_val(cwl_type, value, fmt)
 
-    # ------------------------------
-    # Generate the final workflow inputs by populating the values from the inputs file.
-    # ------------------------------
+    # --------------------------------------------------------
+    # Generate yaml_inputs by populating values from inputs_file_workflow
+    # To be dumped in *_yaml_inputs.yml and passed to CWL workflow execution as --inputs-file
+    # --------------------------------------------------------
     yaml_inputs: WorkflowInputsFile = {}
     for key, in_dict in inputs_file_workflow.items():
         val = populate_input_value(in_dict)
-        # Omit optional-null values only
+        # Omit optional null fields only
         if val is None:
             continue
         yaml_inputs[key] = val