Fix default seeding

Author: guerler

lib/galaxy/tool_util/parameters/__init__.py

@@ -52,6 +52,7 @@
     landing_encode,
     MappedCollectionInput,
     RequestInternalToWorkflowStateError,
+    seed_repeat_defaults,
     strictify,
     to_workflow_step_state,
 )
@@ -188,6 +189,7 @@
     "landing_decode",
     "landing_encode",
     "dereference",
+    "seed_repeat_defaults",
     "strictify",
     "to_workflow_step_state",
     "from_workflow_execution_state",

lib/galaxy/tool_util/parameters/convert.py

@@ -639,6 +639,44 @@ def _initialize_repeat_state(parameter: RepeatParameterModel, tool_state: dict[s
     return repeat_instances
 
 
+def seed_repeat_defaults(tool_state: dict[str, Any], input_models: ToolParameterBundle) -> None:
+    """Seed ``<repeat default="N">`` instances for repeats OMITTED from ``tool_state``, in place.
+
+    The async execution path's legacy meta-parameter visitor rewrites every omitted repeat to
+    ``[]`` before ``fill_static_defaults`` runs, masking the omission so a repeat whose ``default``
+    exceeds its ``min`` never gets seeded. Seeding here - while the omission is still visible -
+    mirrors the legacy ``Repeat.get_initial_value``. Only absent repeats are seeded, so an
+    explicit ``[]`` still means zero; descent is limited to containers already present in the
+    state (fill_static_defaults handles omitted ones and their ``min`` padding).
+    """
+    _seed_repeat_defaults(tool_state, input_models.parameters)
+
+
+def _seed_repeat_defaults(tool_state: dict[str, Any], parameters: Sequence[ToolParameterT]) -> None:
+    for parameter in parameters:
+        if isinstance(parameter, RepeatParameterModel):
+            if parameter.name not in tool_state and not parameter.default:
+                continue
+            for instance_state in _initialize_repeat_state(parameter, tool_state):
+                _seed_repeat_defaults(instance_state, parameter.parameters)
+        elif isinstance(parameter, SectionParameterModel):
+            section_state = tool_state.get(parameter.name)
+            if isinstance(section_state, dict):
+                _seed_repeat_defaults(section_state, parameter.parameters)
+        elif isinstance(parameter, ConditionalParameterModel):
+            conditional_state = tool_state.get(parameter.name)
+            if not isinstance(conditional_state, dict):
+                continue
+            test_parameter_name = parameter.test_parameter.name
+            explicit_test_value = conditional_state.get(test_parameter_name)
+            test_value = validate_explicit_conditional_test_value(test_parameter_name, explicit_test_value)
+            try:
+                when = _select_which_when(parameter, test_value, conditional_state)
+            except Exception:
+                continue
+            _seed_repeat_defaults(conditional_state, when.parameters)
+
+
 def _select_which_when(
     conditional: ConditionalParameterModel, test_value: DiscriminatorType | None, conditional_state: dict[str, Any]
 ) -> ConditionalWhen:

lib/galaxy/tools/__init__.py

@@ -93,6 +93,7 @@
     input_models_for_pages,
     JobInternalToolState,
     RequestInternalDereferencedToolState,
+    seed_repeat_defaults,
 )
 from galaxy.tool_util.parser import (
     get_tool_source,
@@ -2164,6 +2165,14 @@ def expand_incoming_async(
 
         set_dataset_matcher_factory(request_context, self)
 
+        # Seed <repeat default="N"> instances while omitted repeats are still visible, before
+        # expand_meta_parameters_async rewrites every omitted repeat to [] (which would mask the
+        # default from fill_static_defaults for a repeat whose default exceeds its min).
+        if self.parameters is not None:
+            seed_repeat_defaults(
+                tool_request_internal_state.input_state, ToolParameterBundleModel(parameters=self.parameters)
+            )
+
         expanded_incomings: list[ToolStateJobInstanceExpansionT]
         job_tool_states: list[ToolStateJobInstanceT]
         collection_info: MatchingCollections | None

test/unit/tool_util/test_parameter_convert.py

@@ -19,6 +19,7 @@
     RequestInternalDereferencedToolState,
     RequestInternalToolState,
     RequestToolState,
+    seed_repeat_defaults,
     strictify,
 )
 from galaxy.tool_util.parser.util import parse_profile_version
@@ -452,6 +453,36 @@ def _strict_async_decode_and_dereference(
     return dereference(request_internal_state, bundle, _fake_dereference, _fake_collection_deference)
 
 
+def test_seed_repeat_defaults():
+    # <repeat min="0" default="2">: the async execution path materializes an omitted repeat to []
+    # before fill_static_defaults runs, so the default must be seeded earlier - while the omission
+    # is still visible. Regression for the bigscape async failure (default="1" with no min => an
+    # empty --cutoffs argument => argparse exit 2).
+    bundle = input_models_for_tool_source(tool_source_for("parameters/gx_repeat_boolean_default"))
+
+    # Omitted -> seeded with `default` instances.
+    omitted: dict[str, Any] = {}
+    seed_repeat_defaults(omitted, bundle)
+    assert omitted["parameter"] == [{}, {}]
+
+    # Explicit [] still means zero (the omitted-vs-empty distinction is preserved).
+    explicit_empty: dict[str, Any] = {"parameter": []}
+    seed_repeat_defaults(explicit_empty, bundle)
+    assert explicit_empty["parameter"] == []
+
+    # Explicit instances are left untouched.
+    explicit_one: dict[str, Any] = {"parameter": [{"boolean_parameter": True}]}
+    seed_repeat_defaults(explicit_one, bundle)
+    assert explicit_one["parameter"] == [{"boolean_parameter": True}]
+
+    # Seeded instances then get their params filled by fill_static_defaults.
+    seeded = {}
+    seed_repeat_defaults(seeded, bundle)
+    profile = parse_profile_version(tool_source_for("parameters/gx_repeat_boolean_default"))
+    filled = fill_static_defaults(seeded, bundle, profile, partial=True)
+    assert filled["parameter"] == [{"boolean_parameter": False}, {"boolean_parameter": False}]
+
+
 def fill_state_for(tool_state: dict[str, Any], tool_path: str, partial: bool = False) -> dict[str, Any]:
     tool_source = tool_source_for(tool_path)
     bundle = input_models_for_tool_source(tool_source)