moved validation of output_file_template from application of the template (at runtime) to spec validation (at design time)

Author: tclose

pydra/engine/helpers.py

@@ -496,12 +496,6 @@ def output_from_inputfields(output_spec, input_spec):
     new_fields = []
     for fld in attr.fields(make_klass(input_spec)):
         if "output_file_template" in fld.metadata:
-            if fld.type not in (str, ty.Union[str, bool], Path, ty.Union[Path, bool]):
-                raise TypeError(
-                    "Since 'output_file_template' is specified, the type of field "
-                    f"'{fld.name}' must a sub-class of str/Path or a "
-                    "str/Path subclass in union with a bool"
-                )
             if "output_field_name" in fld.metadata:
                 field_name = fld.metadata["output_field_name"]
             else:

pydra/engine/helpers_file.py

@@ -114,7 +114,6 @@ def template_update(inputs, output_dir, state_ind=None, map_copyfiles=None):
             inputs_dict_st[k] = inputs_dict_st[k][v]
 
     from .specs import attr_fields
-    from ..utils.typing import TypeParser
 
     # Collect templated inputs for which all requirements are satisfied.
     fields_templ = [
@@ -129,13 +128,6 @@ def template_update(inputs, output_dir, state_ind=None, map_copyfiles=None):
 
     dict_mod = {}
     for fld in fields_templ:
-        if not TypeParser.is_subclass(
-            fld.type, (str, Path, ty.Union[str, bool], ty.Union[Path, bool])
-        ):
-            raise TypeError(
-                "fields with output_file_template"
-                " has to be a string or Union[str, bool]"
-            )
         dict_mod[fld.name] = template_update_single(
             field=fld,
             inputs=inputs,
@@ -166,11 +158,6 @@ def template_update_single(
         inputs_dict_st = attr.asdict(inputs, recurse=False)
 
     if spec_type == "input":
-        if not TypeParser.is_subclass(field.type, VALID_TYPES):
-            raise TypeError(
-                f"'{field.name}' field has an 'output_file_template' and therefore "
-                f"needs to be typed {VALID_TYPES}, not {field.type}"  # <-- What is the bool option?
-            )
         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

pydra/engine/specs.py

@@ -11,7 +11,6 @@
     File,
     Directory,
 )
-
 import pydra
 from .helpers_file import template_update_single
 from ..utils.hash import hash_function
@@ -366,22 +365,33 @@ def check_metadata(self):
             if set(mdata.keys()) - supported_keys:
                 raise AttributeError(
                     f"only these keys are supported {supported_keys}, but "
-                    f"{set(mdata.keys()) - supported_keys} provided"
+                    f"{set(mdata.keys()) - supported_keys} provided for '{fld.name}' "
+                    f"field in {self}"
                 )
             # checking if the help string is provided (required field)
             if "help_string" not in mdata:
-                raise AttributeError(f"{fld.name} doesn't have help_string field")
-            # assuming that fields with output_file_template shouldn't have default
-            if fld.default not in [attr.NOTHING, True, False] and mdata.get(
-                "output_file_template"
-            ):
                 raise AttributeError(
-                    "default value should not be set together with output_file_template"
+                    f"{fld.name} doesn't have help_string field in {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]):
+                    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']})"
+                    )
+                if fld.default not in [attr.NOTHING, True, False]:
+                    raise AttributeError(
+                        f"default value ({fld.default}) should not be set together with "
+                        f"output_file_template ({mdata['output_file_template']}) for "
+                        f"'{fld.name}' field in {self}"
+                    )
             # not allowing for default if the field is mandatory
             if not fld.default == attr.NOTHING and mdata.get("mandatory"):
                 raise AttributeError(
-                    "default value should not be set when the field is mandatory"
+                    f"default value ({fld.default}) should not be set when the field "
+                    f"('{fld.name}' in {self}) is mandatory"
                 )
             # setting default if value not provided and default is available
             if getattr(self, fld.name) is None:
@@ -571,7 +581,10 @@ def _field_metadata(
                         )
             return callable_(**call_args_val)
         else:
-            raise Exception("(_field_metadata) is not a current valid metadata key.")
+            raise Exception(
+                f"Metadata for '{fld.name}', does not not contain any of the required fields "
+                f'("callable", "output_file_template" or "value"): {fld.metadata}.'
+            )
 
     def _check_requires(self, fld, inputs):
         """checking if all fields from the requires and template are set in the input