Seed <repeat default=N> only when a request omits the repeat

Author: guerler

client/packages/api-client/src/schema/schema.ts

@@ -21585,6 +21585,11 @@ export interface components {
              * @description If the parameter reflects just one command line argument of a certain tool, this tag should be set to that particular argument. It is rendered in parenthesis after the help section, and it will create the name attribute (if not given explicitly) from the argument attribute by stripping leading dashes and replacing all remaining dashes by underscores (e.g. if argument="--long-parameter" then name="long_parameter" is implicit).
              */
             argument?: string | null;
+            /**
+             * Default
+             * @default 0
+             */
+            default: number;
             /**
              * Help
              * @description Short bit of text, rendered on the tool form just below the associated field to provide information about the field.

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/case.py

@@ -1,6 +1,7 @@
 import os
 from dataclasses import (
     dataclass,
+    field,
     replace,
 )
 from re import compile
@@ -291,6 +292,10 @@ class MergeContext:
     profile: str
     state_representation: Literal["test_case_xml", "test_case_json"]
     warnings: list[str]
+    # Names of raw test inputs already claimed by an exact structural match. Shared across the
+    # whole walk (like ``warnings``); consulted only by the repeat bare-name synthesis so a
+    # top-level input a fixed param already consumed can't also seed a nested repeat instance.
+    consumed_input_names: set[str] = field(default_factory=set)
 
     @property
     def inputs(self) -> ToolSourceTestInputs:
@@ -427,14 +432,20 @@ def _merge_into_state(
             )
         )
     elif isinstance(tool_input, (RepeatParameterModel,)):
-        repeat_state_array = state_at_level.get(input_name, [])
-        if input_name not in state_at_level:
-            state_at_level[input_name] = repeat_state_array
-
-        repeat_instance_inputs = _repeat_inputs_to_array(state_path, tool_input.parameters, context.inputs)
+        repeat_instance_inputs = _repeat_inputs_to_array(
+            state_path, tool_input.parameters, context.inputs, context.consumed_input_names
+        )
         if tool_input.min is not None:
             while len(repeat_instance_inputs) < tool_input.min:
                 repeat_instance_inputs.append([])
+        if not repeat_instance_inputs:
+            # The test supplied no instances. Leave the repeat absent rather than materializing an
+            # explicit ``[]`` so request conversion seeds ``default``/``min`` the way the legacy
+            # tool execution does; an explicit ``[]`` would suppress that seeding.
+            return handled_inputs
+        repeat_state_array = state_at_level.get(input_name, [])
+        if input_name not in state_at_level:
+            state_at_level[input_name] = repeat_state_array
         for i, _ in enumerate(repeat_instance_inputs):
             while len(repeat_state_array) <= i:
                 repeat_state_array.append({})
@@ -457,6 +468,10 @@ def _merge_into_state(
     else:
         test_input = context.input_for(state_path)
         if test_input is not None:
+            # An exact-path match means a fixed structural param owns this raw input; record it
+            # so the repeat bare-name synthesis does not re-consume it into a nested instance.
+            if test_input["name"] == state_path:
+                context.consumed_input_names.add(test_input["name"])
             input_value: Any
             if isinstance(tool_input, (DataCollectionParameterModel,)):
                 input_value = TestCollectionDef.from_dict(
@@ -505,7 +520,10 @@ def _merge_into_state(
 
 
 def _repeat_inputs_to_array(
-    state_path: str, parameters: list[ToolParameterT], inputs: ToolSourceTestInputs
+    state_path: str,
+    parameters: list[ToolParameterT],
+    inputs: ToolSourceTestInputs,
+    consumed_input_names: set[str] | None = None,
 ) -> list[ToolSourceTestInputs]:
     inputs_as_dict = _inputs_as_dict(inputs)
     repeat_instance_input_dicts = repeat_inputs_to_array(state_path, inputs_as_dict)
@@ -524,17 +542,50 @@ def _repeat_inputs_to_array(
     if repeat_instance_inputs:
         return repeat_instance_inputs
 
+    consumed = consumed_input_names or set()
     legacy_repeat_inputs: list[ToolSourceTestInputs] = []
     for parameter in parameters:
         parameter_name = parameter.name
-        matching_inputs = [input for input in inputs if input["name"] == parameter_name]
+        matching_inputs = [
+            input for input in inputs if input["name"] == parameter_name and input["name"] not in consumed
+        ]
         for i, input in enumerate(matching_inputs):
             while len(legacy_repeat_inputs) <= i:
                 legacy_repeat_inputs.append([])
             synthetic_input = cast(ToolSourceTestInput, dict(input))
             synthetic_input["name"] = f"{state_path}_{i}|{parameter_name}"
             legacy_repeat_inputs[i].append(synthetic_input)
-    return legacy_repeat_inputs
+    if legacy_repeat_inputs:
+        return legacy_repeat_inputs
+
+    # The repeat's instance params live inside a conditional/section and the legacy test names
+    # them by bare short name (e.g. deepmicro's parameter_set repeat wraps an rl_type conditional
+    # whose test supplies rl_type_choice/dm unqualified). Group those unconsumed matches into
+    # instances - one per occurrence count - so instance-scoped resolution re-attaches them.
+    return _nested_repeat_inputs_to_array(parameters, inputs, consumed)
+
+
+def _nested_repeat_inputs_to_array(
+    parameters: list[ToolParameterT], inputs: ToolSourceTestInputs, consumed: set[str]
+) -> list[ToolSourceTestInputs]:
+    leaf_names = _leaf_param_short_names(parameters)
+    matches_by_leaf: dict[str, list[ToolSourceTestInput]] = {}
+    for leaf_name in leaf_names:
+        matches = [input for input in inputs if input["name"] == leaf_name and input["name"] not in consumed]
+        if matches:
+            matches_by_leaf[leaf_name] = matches
+    if not matches_by_leaf:
+        return []
+    instance_count = max(len(matches) for matches in matches_by_leaf.values())
+    nested_repeat_inputs: list[ToolSourceTestInputs] = [[] for _ in range(instance_count)]
+    for leaf_name, matches in matches_by_leaf.items():
+        for i, input in enumerate(matches):
+            synthetic_input = cast(ToolSourceTestInput, dict(input))
+            # Keep the bare leaf name; the instance-scoped short-name fallback re-attaches it to
+            # its fully qualified path within the conditional/section.
+            synthetic_input["name"] = leaf_name
+            nested_repeat_inputs[i].append(synthetic_input)
+    return nested_repeat_inputs
 
 
 def _select_which_when(

lib/galaxy/tool_util/parameters/convert.py

@@ -628,15 +628,55 @@ def _initialize_conditional_state(parameter: ConditionalParameterModel, tool_sta
 
 def _initialize_repeat_state(parameter: RepeatParameterModel, tool_state: dict[str, Any]) -> list[dict[str, Any]]:
     parameter_name = parameter.name
-    if parameter_name not in tool_state:
+    supplied = parameter_name in tool_state
+    if not supplied:
         tool_state[parameter_name] = []
     repeat_instances = cast(list[dict[str, Any]], tool_state[parameter_name])
-    if parameter.min:
-        while len(repeat_instances) < parameter.min:
-            repeat_instances.append({})
+    # ``default`` seeds an omitted repeat; an explicit ``[]`` means zero. ``min`` always pads.
+    floor = parameter.default if not supplied else (parameter.min or 0)
+    while len(repeat_instances) < floor:
+        repeat_instances.append({})
     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/tool_util/parameters/factory.py

@@ -391,14 +391,22 @@ def _from_input_source_galaxy(input_source: InputSource, profile: float) -> Tool
         instance_tool_parameter_models = input_models_for_page(instance_sources, profile)
         min_raw = input_source.get("min", None)
         max_raw = input_source.get("max", None)
+        default_raw = input_source.get("default", None)
         min = int(min_raw) if min_raw is not None else None
         max = int(max_raw) if max_raw is not None else None
+        default = int(default_raw) if default_raw is not None else 0
+        # Clamp the seed count into [min, max].
+        if min is not None and default < min:
+            default = min
+        if max is not None and default > max:
+            default = max
         return RepeatParameterModel(
             type="repeat",
             name=name,
             parameters=instance_tool_parameter_models,
             min=min,
             max=max,
+            default=default,
             **_common_param_kwargs(input_source),
         )
     elif input_type == "section":

lib/galaxy/tool_util_models/parameters.py

@@ -2397,6 +2397,8 @@ class RepeatParameterModel(BaseGalaxyToolParameterModelDefinition):
     parameters: list["ToolParameterT"]
     min: int | None = None
     max: int | None = None
+    # ``<repeat default="N">``: instances to seed when a request omits the repeat.
+    default: int = 0
 
     def field_kwargs(self) -> dict[str, Any]:
         kwargs = super().field_kwargs()

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

lib/galaxy_test/api/test_tool_execute.py

@@ -726,6 +726,13 @@ def test_optional_repeats_with_mins_filled_id(target_history: TargetHistory, req
     required_tool.execute().assert_has_single_job.with_single_output.containing("false").containing("length: 2")
 
 
+@requires_tool_id("gx_repeat_boolean_default")
+def test_optional_repeats_with_default_seeded(target_history: TargetHistory, required_tool: RequiredTool):
+    # <repeat min="0" default="2">: a request that omits the repeat is seeded with two
+    # instances. An explicit empty repeat yields zero - covered in test_parameter_convert.py.
+    required_tool.execute().assert_has_single_job.with_single_output.containing("length: 2")
+
+
 @requires_tool_id("gx_select")
 @requires_tool_id("gx_select_no_options_validation")
 def test_select_first_by_default(required_tools: list[RequiredTool], tool_input_format: DescribeToolInputs):

lib/tool_shed/webapp/frontend/src/schema/schema.ts

@@ -2648,6 +2648,11 @@ export interface components {
              * @description If the parameter reflects just one command line argument of a certain tool, this tag should be set to that particular argument. It is rendered in parenthesis after the help section, and it will create the name attribute (if not given explicitly) from the argument attribute by stripping leading dashes and replacing all remaining dashes by underscores (e.g. if argument="--long-parameter" then name="long_parameter" is implicit).
              */
             argument?: string | null
+            /**
+             * Default
+             * @default 0
+             */
+            default: number
             /**
              * Help
              * @description Short bit of text, rendered on the tool form just below the associated field to provide information about the field.

test/functional/tools/parameters/gx_repeat_boolean_default.xml

@@ -0,0 +1,14 @@
+<tool id="gx_repeat_boolean_default" name="gx_repeat_boolean_default" version="1.0.0">
+    <command><![CDATA[
+#set $repeat_length = len($parameter)
+echo 'length: $repeat_length' >> '$output'
+    ]]></command>
+    <inputs>
+        <repeat name="parameter" title="Repeat Parameter" min="0" default="2">
+            <param name="boolean_parameter" type="boolean" />
+        </repeat>
+    </inputs>
+    <outputs>
+        <data name="output" format="txt" />
+    </outputs>
+</tool>