added label to type parser

Author: tclose

pydra/engine/helpers.py

@@ -261,7 +261,8 @@ def make_klass(spec):
                     type=tp,
                     **kwargs,
                 )
-            type_checker = TypeParser[newfield.type](newfield.type)
+            checker_label = f"'{name}' field of {spec.name}"
+            type_checker = TypeParser[newfield.type](newfield.type, label=checker_label)
             if newfield.type in (MultiInputObj, MultiInputFile):
                 converter = attr.converters.pipe(ensure_list, type_checker)
             elif newfield.type in (MultiOutputObj, MultiOutputFile):

pydra/engine/specs.py

@@ -450,7 +450,8 @@ def collect_additional_outputs(self, inputs, output_dir, outputs):
             input_value = getattr(inputs, fld.name, attr.NOTHING)
             if input_value is not attr.NOTHING:
                 if TypeParser.contains_type(FileSet, fld.type):
-                    input_value = TypeParser(fld.type).coerce(input_value)
+                    label = f"output field '{fld.name}' of {self}"
+                    input_value = TypeParser(fld.type, label=label).coerce(input_value)
                 additional_out[fld.name] = input_value
             elif (
                 fld.default is None or fld.default == attr.NOTHING

pydra/utils/typing.py

@@ -56,11 +56,15 @@ class TypeParser(ty.Generic[T]):
         the tree of more complex nested container types. Overrides 'coercible' to enable
         you to carve out exceptions, such as TypeParser(list, coercible=[(ty.Iterable, list)],
         not_coercible=[(str, list)])
+    label : str
+        the label to be used to identify the type parser in error messages. Especially
+        useful when TypeParser is used as a converter in attrs.fields
     """
 
     tp: ty.Type[T]
     coercible: ty.List[ty.Tuple[TypeOrAny, TypeOrAny]]
     not_coercible: ty.List[ty.Tuple[TypeOrAny, TypeOrAny]]
+    label: str
 
     COERCIBLE_DEFAULT: ty.Tuple[ty.Tuple[type, type], ...] = (
         (
@@ -103,6 +107,7 @@ def __init__(
         not_coercible: ty.Optional[
             ty.Iterable[ty.Tuple[TypeOrAny, TypeOrAny]]
         ] = NOT_COERCIBLE_DEFAULT,
+        label: str = "",
     ):
         def expand_pattern(t):
             """Recursively expand the type arguments of the target type in nested tuples"""
@@ -118,10 +123,12 @@ def expand_pattern(t):
                 return origin
             if origin not in (ty.Union, type) and not issubclass(origin, ty.Iterable):
                 raise TypeError(
-                    f"TypeParser doesn't know how to handle args ({args}) for {origin} types"
+                    f"TypeParser doesn't know how to handle args ({args}) for {origin} "
+                    f"types{self.label_str}"
                 )
             return (origin, [expand_pattern(a) for a in args])
 
+        self.label = label
         self.tp = tp
         self.coercible = (
             list(coercible) if coercible is not None else [(ty.Any, ty.Any)]
@@ -194,7 +201,7 @@ def expand_and_coerce(obj, pattern: ty.Union[type, tuple]):
                     else ""
                 )
                 raise TypeError(
-                    f"Could not coerce to {type_} as {obj!r} is not iterable{msg}"
+                    f"Could not coerce to {type_} as {obj!r} is not iterable{msg}{self.label_str}"
                 ) from e
             if issubclass(origin, tuple):
                 return coerce_tuple(type_, obj_args, pattern_args)
@@ -221,7 +228,8 @@ def coerce_union(obj, pattern_args):
                 except TypeError as e:
                     reasons.append(e)
             raise TypeError(
-                f"Could not coerce object, {obj!r}, to any of the union types {pattern_args}:\n\n"
+                f"Could not coerce object, {obj!r}, to any of the union types "
+                f"{pattern_args}{self.label_str}:\n\n"
                 + "\n\n".join(f"{a} -> {e}" for a, e in zip(pattern_args, reasons))
             )
 
@@ -240,7 +248,7 @@ def coerce_mapping(
                     else ""
                 )
                 raise TypeError(
-                    f"Could not coerce to {type_} as {obj} is not a mapping type{msg}"
+                    f"Could not coerce to {type_} as {obj} is not a mapping type{msg}{self.label_str}"
                 ) from e
             return coerce_obj(
                 {
@@ -263,7 +271,7 @@ def coerce_tuple(
             elif len(pattern_args) != len(obj_args):
                 raise TypeError(
                     f"Incorrect number of items in tuple, expected "
-                    f"{len(pattern_args)}, got {len(obj_args)}"
+                    f"{len(pattern_args)}, got {len(obj_args)}{self.label_str}"
                 )
             return coerce_obj(
                 [expand_and_coerce(o, p) for o, p in zip(obj_args, pattern_args)], type_
@@ -281,7 +289,7 @@ def coerce_sequence(
         def coerce_type(type_: ty.Type[ty.Any], pattern_args: ty.List[ty.Type[ty.Any]]):
             if not any(issubclass(type_, t) for t in pattern_args):
                 raise TypeError(
-                    f"{type_} is not one of the specified types {pattern_args}"
+                    f"{type_} is not one of the specified types {pattern_args}{self.label_str}"
                 )
             return type_
 
@@ -297,7 +305,9 @@ def coerce_obj(obj, type_):
                     if obj is not object_
                     else ""
                 )
-                raise TypeError(f"Cannot coerce {obj!r} into {type_}{msg}") from e
+                raise TypeError(
+                    f"Cannot coerce {obj!r} into {type_}{msg}{self.label_str}"
+                ) from e
 
         return expand_and_coerce(object_, self.pattern)
 
@@ -323,7 +333,7 @@ def check_type(self, type_: ty.Type[ty.Any]):
                 raise TypeError("Splits without any type arguments are invalid")
             if len(args) > 1:
                 raise TypeError(
-                    f"Splits with more than one type argument ({args}) are invalid"
+                    f"Splits with more than one type argument ({args}) are invalid{self.label_str}"
                 )
             return self.check_type(args[0])
 
@@ -343,7 +353,7 @@ def expand_and_check(tp, pattern: ty.Union[type, tuple]):
                     )
                 raise TypeError(
                     f"{tp} doesn't match pattern {pattern}, when matching {type_} to "
-                    f"{self.pattern}"
+                    f"{self.pattern}{self.label_str}"
                 )
             tp_args = get_args(tp)
             self.check_coercible(tp_origin, pattern_origin)
@@ -378,7 +388,7 @@ def check_union(tp, pattern_args):
                     if reasons:
                         raise TypeError(
                             f"Cannot coerce {tp} to "
-                            f"ty.Union[{', '.join(str(a) for a in pattern_args)}], "
+                            f"ty.Union[{', '.join(str(a) for a in pattern_args)}]{self.label_str}, "
                             f"because {tp_arg} cannot be coerced to any of its args:\n\n"
                             + "\n\n".join(
                                 f"{a} -> {e}" for a, e in zip(pattern_args, reasons)
@@ -414,7 +424,7 @@ def check_tuple(tp_args, pattern_args):
             if len(tp_args) != len(pattern_args):
                 raise TypeError(
                     f"Wrong number of type arguments in tuple {tp_args}  compared to pattern "
-                    f"{pattern_args} in attempting to match {type_} to {self.pattern}"
+                    f"{pattern_args} in attempting to match {type_} to {self.pattern}{self.label_str}"
                 )
             for t, p in zip(tp_args, pattern_args):
                 expand_and_check(t, p)
@@ -426,7 +436,8 @@ def check_sequence(tp_args, pattern_args):
                 if not tp_args:
                     raise TypeError(
                         "Generic ellipsis type arguments not specific enough to match "
-                        f"{pattern_args} in attempting to match {type_} to {self.pattern}"
+                        f"{pattern_args} in attempting to match {type_} to "
+                        f"{self.pattern}{self.label_str}"
                     )
             for arg in tp_args:
                 expand_and_check(arg, pattern_args[0])
@@ -476,16 +487,16 @@ def type_name(t):
 
         if not matches_criteria(self.coercible):
             raise TypeError(
-                f"Cannot coerce {repr(source)} into {target} as the coercion doesn't match "
-                f"any of the explicit inclusion criteria: "
+                f"Cannot coerce {repr(source)} into {target}{self.label_str} as the "
+                "coercion doesn't match any of the explicit inclusion criteria: "
                 + ", ".join(
                     f"{type_name(s)} -> {type_name(t)}" for s, t in self.coercible
                 )
             )
         matches_not_coercible = matches_criteria(self.not_coercible)
         if matches_not_coercible:
             raise TypeError(
-                f"Cannot coerce {repr(source)} into {target} as it is explicitly "
+                f"Cannot coerce {repr(source)} into {target}{self.label_str} as it is explicitly "
                 "excluded by the following coercion criteria: "
                 + ", ".join(
                     f"{type_name(s)} -> {type_name(t)}"
@@ -799,5 +810,9 @@ def strip_splits(cls, type_: ty.Type[ty.Any]) -> ty.Tuple[ty.Type, int]:
             depth += 1
         return type_, depth
 
+    @property
+    def label_str(self):
+        return f" in {self.label} " if self.label else ""
+
     get_origin = staticmethod(get_origin)
     get_args = staticmethod(get_args)