added in "modify|" syntax as discussed with @satra

Author: tclose

pydra/design/shell.py

@@ -461,7 +461,7 @@ def parse_command_line_template(
         return template, inputs, outputs
     executable, args_str = parts
     tokens = re.split(r"\s+", args_str.strip())
-    arg_pattern = r"<([:a-zA-Z0-9_,\|\-\.\/\+]+\??)>"
+    arg_pattern = r"<([:a-zA-Z0-9_,\|\-\.\/\+]+(?:\?|=[^>]+)?)>"
     opt_pattern = r"--?[a-zA-Z0-9_]+"
     arg_re = re.compile(arg_pattern)
     opt_re = re.compile(opt_pattern)
@@ -470,10 +470,8 @@ def parse_command_line_template(
     arguments = []
     option = None
 
-    def add_arg(name, field_type, kwds, is_option=False):
+    def add_arg(name, field_type, kwds):
         """Merge the typing information with an existing field if it exists"""
-        if is_option and kwds["type"] is not bool:
-            kwds["type"] |= None
         if issubclass(field_type, Out):
             dct = outputs
         else:
@@ -497,7 +495,8 @@ def add_arg(name, field_type, kwds, is_option=False):
             for k, v in kwds.items():
                 setattr(field, k, v)
         dct[name] = field
-        arguments.append(field)
+        if issubclass(field_type, Arg):
+            arguments.append(field)
 
     def from_type_str(type_str) -> type:
         types = []
@@ -528,9 +527,14 @@ def from_type_str(type_str) -> type:
     for token in tokens:
         if match := arg_re.match(token):
             name = match.group(1)
+            modify = False
             if name.startswith("out|"):
                 name = name[4:]
                 field_type = outarg
+            elif name.startswith("modify|"):
+                name = name[7:]
+                field_type = arg
+                modify = True
             else:
                 field_type = arg
             # Identify type after ':' symbols
@@ -539,14 +543,22 @@ def from_type_str(type_str) -> type:
                 optional = True
             else:
                 optional = False
+            kwds = {}
+            if "=" in name:
+                name, default = name.split("=")
+                kwds["default"] = eval(default)
             if ":" in name:
                 name, type_str = name.split(":")
                 type_ = from_type_str(type_str)
             else:
                 type_ = generic.FsObject if option is None else str
             if optional:
                 type_ |= None  # Make the arguments optional
-            kwds = {"type": type_}
+            kwds["type"] = type_
+            if modify:
+                kwds["copy_mode"] = generic.File.CopyMode.copy
+                # Add field to outputs with the same name as the input
+                add_arg(name, out, {"type": type_, "callable": _InputPassThrough(name)})
             # If name contains a '.', treat it as a file template and strip it from the name
             if field_type is outarg:
                 path_template = name
@@ -566,6 +578,7 @@ def from_type_str(type_str) -> type:
                 kwds["argstr"] = option
                 add_arg(name, field_type, kwds)
                 option = None
+
         elif match := bool_arg_re.match(token):
             argstr, var = match.groups()
             add_arg(var, arg, {"type": bool, "argstr": argstr, "default": False})
@@ -626,3 +639,13 @@ def remaining_positions(
             f"Multiple fields have the overlapping positions: {multiple_positions}"
         )
     return [i for i in range(start, num_args) if i not in positions]
+
+
+@attrs.define
+class _InputPassThrough:
+    """A class that can be used to pass through an input to the output"""
+
+    name: str
+
+    def __call__(self, inputs: ShellSpec) -> ty.Any:
+        return getattr(inputs, self.name)

pydra/design/tests/test_shell.py

@@ -71,6 +71,34 @@ def test_interface_template_w_types_and_path_template_ext():
     SampleInterface.Outputs(out_image=image.Png.mock())
 
 
+def test_interface_template_w_modify():
+
+    SampleInterface = shell.define("trim-png <modify|image:image/png>")
+
+    assert issubclass(SampleInterface, ShellSpec)
+    assert sorted_fields(SampleInterface) == [
+        shell.arg(
+            name="executable",
+            default="trim-png",
+            type=str | ty.Sequence[str],
+            position=0,
+            help_string=shell.EXECUTABLE_HELP_STRING,
+        ),
+        shell.arg(
+            name="image", type=image.Png, position=1, copy_mode=File.CopyMode.copy
+        ),
+    ]
+    assert sorted_fields(SampleInterface.Outputs) == [
+        shell.out(
+            name="image",
+            type=image.Png,
+            callable=shell._InputPassThrough("image"),
+        )
+    ]
+    SampleInterface(image=image.Png.mock())
+    SampleInterface.Outputs(image=image.Png.mock())
+
+
 def test_interface_template_more_complex():
 
     SampleInterface = shell.define(

pydra/engine/state.py

@@ -111,6 +111,11 @@ def __str__(self):
             f"and combiner: {self.combiner}"
         )
 
+    @property
+    def depth(self):
+        """Return the number of uncombined splits of the state."""
+        return len(self.states_ind)
+
     @property
     def splitter(self):
         """Get the splitter of the state."""

pydra/engine/workflow/node.py

@@ -81,8 +81,26 @@ def inputs(self) -> Inputs:
 
     @property
     def state(self):
+        """Initialise the state of the node just after it has been created (i.e. before
+        it has been split or combined) based on the upstream connections
+        """
         if self._state is not NOT_SET:
             return self._state
+        upstream_states = self._upstream_states()
+        if upstream_states:
+            state = State(
+                self.name,
+                splitter=None,
+                other_states=upstream_states,
+                combiner=None,
+            )
+        else:
+            state = None
+        self._state = state
+        return state
+
+    def _upstream_states(self):
+        """Get the states of the upstream nodes that are connected to this node"""
         upstream_states = {}
         for inpt_name, val in self.input_values:
             if isinstance(val, lazy.LazyOutField) and val.node.state:
@@ -97,17 +115,7 @@ def state(self):
                     # if the task already exist in other_state,
                     # additional field name should be added to the list of fields
                     upstream_states[node.name][1].append(inpt_name)
-        if upstream_states:
-            state = State(
-                node.name,
-                splitter=None,
-                other_states=upstream_states,
-                combiner=None,
-            )
-        else:
-            state = None
-        self._state = state
-        return state
+        return upstream_states
 
     @property
     def input_values(self) -> tuple[tuple[str, ty.Any]]:
@@ -248,7 +256,7 @@ def combine(
             raise Exception("combiner has to be a string or a list")
         combiner = hlpst.add_name_combiner(ensure_list(combiner), self.name)
         if not_split := [
-            c for c in combiner if not any(c in s for s in self.state.splitter)
+            c for c in combiner if not any(c in s for s in self.state.splitter_rpn)
         ]:
             raise ValueError(
                 f"Combiner fields {not_split} for Node {self.name!r} are not in the "