fixed up the type-checking of fields with output_file_template

Author: tclose

pydra/engine/helpers_file.py

@@ -151,25 +151,21 @@ def template_update_single(
     # if input_dict_st with state specific value is not available,
     # the dictionary will be created from inputs object
     from ..utils.typing import TypeParser  # noqa
-    from pydra.engine.specs import LazyField
-
-    VALID_TYPES = (str, ty.Union[str, bool], Path, ty.Union[Path, bool], LazyField)
+    from pydra.engine.specs import LazyField, OUTPUT_TEMPLATE_TYPES
 
     if inputs_dict_st is None:
         inputs_dict_st = attr.asdict(inputs, recurse=False)
 
     if spec_type == "input":
         inp_val_set = inputs_dict_st[field.name]
-        if inp_val_set is not attr.NOTHING and not TypeParser.is_instance(
-            inp_val_set, VALID_TYPES
-        ):
-            raise TypeError(
-                f"'{field.name}' field has to be a Path instance or a bool, but {inp_val_set} set"
-            )
         if isinstance(inp_val_set, bool) and field.type in (Path, str):
             raise TypeError(
                 f"type of '{field.name}' is Path, consider using Union[Path, bool]"
             )
+        if inp_val_set is not attr.NOTHING and not isinstance(LazyField):
+            inp_val_set = TypeParser(ty.Union.__getitem__(OUTPUT_TEMPLATE_TYPES))(
+                inp_val_set
+            )
     elif spec_type == "output":
         if not TypeParser.contains_type(FileSet, field.type):
             raise TypeError(
@@ -179,22 +175,23 @@ def template_update_single(
     else:
         raise TypeError(f"spec_type can be input or output, but {spec_type} provided")
     # for inputs that the value is set (so the template is ignored)
-    if spec_type == "input" and isinstance(inputs_dict_st[field.name], (str, Path)):
-        return inputs_dict_st[field.name]
-    elif spec_type == "input" and inputs_dict_st[field.name] is False:
-        # if input fld is set to False, the fld shouldn't be used (setting NOTHING)
-        return attr.NOTHING
-    else:  # inputs_dict[field.name] is True or spec_type is output
-        value = _template_formatting(field, inputs, inputs_dict_st)
-        # changing path so it is in the output_dir
-        if output_dir and value is not attr.NOTHING:
-            # should be converted to str, it is also used for input fields that should be str
-            if type(value) is list:
-                return [str(output_dir / Path(val).name) for val in value]
-            else:
-                return str(output_dir / Path(value).name)
-        else:
+    if spec_type == "input":
+        if isinstance(inp_val_set, (Path, list)):
+            return inp_val_set
+        if inp_val_set is False:
+            # if input fld is set to False, the fld shouldn't be used (setting NOTHING)
             return attr.NOTHING
+    # inputs_dict[field.name] is True or spec_type is output
+    value = _template_formatting(field, inputs, inputs_dict_st)
+    # changing path so it is in the output_dir
+    if output_dir and value is not attr.NOTHING:
+        # should be converted to str, it is also used for input fields that should be str
+        if type(value) is list:
+            return [str(output_dir / Path(val).name) for val in value]
+        else:
+            return str(output_dir / Path(value).name)
+    else:
+        return attr.NOTHING
 
 
 def _template_formatting(field, inputs, inputs_dict_st):

pydra/engine/specs.py

@@ -46,6 +46,13 @@ class MultiOutputType:
 MultiOutputObj = ty.Union[list, object, MultiOutputType]
 MultiOutputFile = ty.Union[File, ty.List[File], MultiOutputType]
 
+OUTPUT_TEMPLATE_TYPES = (
+    Path,
+    ty.List[Path],
+    ty.Union[Path, bool],
+    ty.Union[ty.List[Path], bool],
+)
+
 
 @attr.s(auto_attribs=True, kw_only=True)
 class SpecInfo:
@@ -343,6 +350,8 @@ def check_metadata(self):
         Also sets the default values when available and needed.
 
         """
+        from ..utils.typing import TypeParser
+
         supported_keys = {
             "allowed_values",
             "argstr",
@@ -361,6 +370,7 @@ def check_metadata(self):
             "formatter",
             "_output_type",
         }
+
         for fld in attr_fields(self, exclude_names=("_func", "_graph_checksums")):
             mdata = fld.metadata
             # checking keys from metadata
@@ -377,16 +387,13 @@ def check_metadata(self):
                 )
             # assuming that fields with output_file_template shouldn't have default
             if mdata.get("output_file_template"):
-                if fld.type not in (
-                    Path,
-                    ty.Union[Path, bool],
-                    str,
-                    ty.Union[str, bool],
+                if not any(
+                    TypeParser.matches_type(fld.type, t) for t in OUTPUT_TEMPLATE_TYPES
                 ):
                     raise TypeError(
-                        f"Type of '{fld.name}' should be either pathlib.Path or "
-                        f"typing.Union[pathlib.Path, bool] (not {fld.type}) because "
-                        f"it has a value for output_file_template ({mdata['output_file_template']!r})"
+                        f"Type of '{fld.name}' should be one of {OUTPUT_TEMPLATE_TYPES} "
+                        f"(not {fld.type}) because it has a value for output_file_template "
+                        f"({mdata['output_file_template']!r})"
                     )
                 if fld.default not in [attr.NOTHING, True, False]:
                     raise AttributeError(