fixing support for multInputObjs

Author: tclose

pydra/design/base.py

@@ -833,7 +833,7 @@ def extract_function_inputs_and_outputs(
         if isinstance(inpt, arg_type):
             if inpt.default is EMPTY:
                 inpt.default = default
-        elif inspect.isclass(inpt):
+        elif inspect.isclass(inpt) or ty.get_origin(inpt):
             inputs[inpt_name] = arg_type(type=inpt, default=default)
         else:
             raise ValueError(

pydra/design/shell.py

@@ -100,17 +100,25 @@ class arg(Arg):
     formatter: ty.Callable | None = None
 
     @sep.validator
-    def _validate_sep(self, attribute, value):
-        if (
-            value is not None
-            and self.type is not ty.Any
-            and ty.get_origin(self.type) is not MultiInputObj
-        ):
-            tp = ty.get_origin(self.type) or self.type
-            if not issubclass(tp, ty.Iterable):
+    def _validate_sep(self, _, sep):
+        if self.type is ty.Any:
+            return
+        if ty.get_origin(self.type) is MultiInputObj:
+            tp = ty.get_args(self.type)[0]
+        else:
+            tp = self.type
+        origin = ty.get_origin(tp) or tp
+        if inspect.isclass(origin) and issubclass(origin, ty.Iterable):
+            if sep is None:
                 raise ValueError(
-                    f"sep ({value!r}) can only be provided when type is iterable"
+                    f"A value to 'sep' must be provided when type is iterable {tp} "
+                    f"for field {self.name!r}"
                 )
+        elif sep is not None:
+            raise ValueError(
+                f"sep ({sep!r}) can only be provided when type is iterable {tp} "
+                f"for field {self.name!r}"
+            )
 
 
 @attrs.define(kw_only=True)

pydra/engine/core.py

@@ -554,7 +554,7 @@ def _check_for_hash_changes(self):
                     f"- {changed}: the {field_type} object passed to the {field.type}"
                     f"field appears to have an unstable hash. This could be due to "
                     "a stochastic/non-thread-safe attribute(s) of the object\n\n"
-                    f"The {field.type}.__bytes_repr__() method can be implemented to "
+                    f'A "bytes_repr" method for {field.type!r} can be implemented to '
                     "bespoke hashing methods based only on the stable attributes for "
                     f"the `{field_type.__module__}.{field_type.__name__}` type. "
                     f"See pydra/utils/hash.py for examples. Value: {val}\n"

pydra/engine/specs.py

@@ -31,7 +31,7 @@
 from . import helpers_state as hlpst
 from . import lazy
 from pydra.utils.hash import hash_function, Cache
-from pydra.utils.typing import StateArray
+from pydra.utils.typing import StateArray, MultiInputObj
 from pydra.design.base import Field, Arg, Out, RequirementSet, EMPTY
 from pydra.design import shell
 from pydra.engine.lazy import LazyInField, LazyOutField
@@ -1126,47 +1126,50 @@ def _command_pos_args(
             # if False, nothing is added to the command.
             if value is True:
                 cmd_add.append(field.argstr)
+        elif ty.get_origin(field.type) is MultiInputObj:
+            # if the field is MultiInputObj, it is used to create a list of arguments
+            for val in value or []:
+                cmd_add += self._format_arg(field, val)
         else:
-            if (
-                field.argstr.endswith("...")
-                and isinstance(value, ty.Iterable)
-                and not isinstance(value, (str, bytes))
-            ):
-                field.argstr = field.argstr.replace("...", "")
-                # if argstr has a more complex form, with "{input_field}"
-                if "{" in field.argstr and "}" in field.argstr:
-                    argstr_formatted_l = []
-                    for val in value:
-                        argstr_f = argstr_formatting(
-                            field.argstr, self, value_updates={field.name: val}
-                        )
-                        argstr_formatted_l.append(f" {argstr_f}")
-                    cmd_el_str = field.sep.join(argstr_formatted_l)
-                else:  # argstr has a simple form, e.g. "-f", or "--f"
-                    cmd_el_str = field.sep.join(
-                        [f" {field.argstr} {val}" for val in value]
-                    )
-            else:
-                # in case there are ... when input is not a list
-                field.argstr = field.argstr.replace("...", "")
-                if isinstance(value, ty.Iterable) and not isinstance(
-                    value, (str, bytes)
-                ):
-                    cmd_el_str = field.sep.join([str(val) for val in value])
-                    value = cmd_el_str
-                # if argstr has a more complex form, with "{input_field}"
-                if "{" in field.argstr and "}" in field.argstr:
-                    cmd_el_str = field.argstr.replace(f"{{{field.name}}}", str(value))
-                    cmd_el_str = argstr_formatting(cmd_el_str, self.definition)
-                else:  # argstr has a simple form, e.g. "-f", or "--f"
-                    if value:
-                        cmd_el_str = f"{field.argstr} {value}"
-                    else:
-                        cmd_el_str = ""
-            if cmd_el_str:
-                cmd_add += split_cmd(cmd_el_str)
+            cmd_add += self._format_arg(field, value)
         return field.position, cmd_add
 
+    def _format_arg(self, field: shell.arg, value: ty.Any) -> list[str]:
+        """Returning arguments used to specify the command args for a single inputs"""
+        if (
+            field.argstr.endswith("...")
+            and isinstance(value, ty.Iterable)
+            and not isinstance(value, (str, bytes))
+        ):
+            field.argstr = field.argstr.replace("...", "")
+            # if argstr has a more complex form, with "{input_field}"
+            if "{" in field.argstr and "}" in field.argstr:
+                argstr_formatted_l = []
+                for val in value:
+                    argstr_f = argstr_formatting(
+                        field.argstr, self, value_updates={field.name: val}
+                    )
+                    argstr_formatted_l.append(f" {argstr_f}")
+                cmd_el_str = field.sep.join(argstr_formatted_l)
+            else:  # argstr has a simple form, e.g. "-f", or "--f"
+                cmd_el_str = field.sep.join([f" {field.argstr} {val}" for val in value])
+        else:
+            # in case there are ... when input is not a list
+            field.argstr = field.argstr.replace("...", "")
+            if isinstance(value, ty.Iterable) and not isinstance(value, (str, bytes)):
+                cmd_el_str = field.sep.join([str(val) for val in value])
+                value = cmd_el_str
+            # if argstr has a more complex form, with "{input_field}"
+            if "{" in field.argstr and "}" in field.argstr:
+                cmd_el_str = field.argstr.replace(f"{{{field.name}}}", str(value))
+                cmd_el_str = argstr_formatting(cmd_el_str, self)
+            else:  # argstr has a simple form, e.g. "-f", or "--f"
+                if value:
+                    cmd_el_str = f"{field.argstr} {value}"
+                else:
+                    cmd_el_str = ""
+        return split_cmd(cmd_el_str)
+
     def _get_bindings(self, root: str | None = None) -> dict[str, tuple[str, str]]:
         """Return bindings necessary to run task in an alternative root.
 
@@ -1259,7 +1262,7 @@ def reset(self):
             setattr(self, val, donothing)
 
 
-def split_cmd(cmd: str):
+def split_cmd(cmd: str | None):
     """Splits a shell command line into separate arguments respecting quotes
 
     Parameters
@@ -1272,6 +1275,8 @@ def split_cmd(cmd: str):
     str
         the command line string split into process args
     """
+    if cmd is None:
+        return []
     # Check whether running on posix or Windows system
     on_posix = platform.system() != "Windows"
     args = shlex.split(cmd, posix=on_posix)