Fix tool_instance_name: resolve instance names to real tool names in save_parameters, add support in input_TOPP, run_topp, and get_topp_parameters

Co-authored-by: t0mdavid-m <57191390+t0mdavid-m@users.noreply.github.com>

Author: Copilot

src/workflow/CommandExecutor.py

@@ -216,7 +216,7 @@ def read_stderr():
         stdout_thread.join()
         stderr_thread.join()
 
-    def run_topp(self, tool: str, input_output: dict, custom_params: dict = {}) -> bool:
+    def run_topp(self, tool: str, input_output: dict, custom_params: dict = {}, tool_instance_name: str = None) -> bool:
         """
         Constructs and executes commands for the specified tool OpenMS TOPP tool based on the given
         input and output configurations. Ensures that all input/output file lists
@@ -234,6 +234,9 @@ def run_topp(self, tool: str, input_output: dict, custom_params: dict = {}) -> b
             tool (str): The executable name or path of the tool.
             input_output (dict): A dictionary specifying the input/output parameter names (as key) and their corresponding file paths (as value).
             custom_params (dict): A dictionary of custom parameters to pass to the tool.
+            tool_instance_name (str, optional): A unique instance name for this tool
+                invocation, used for parameter lookup when multiple instances of the
+                same tool exist. If not provided, defaults to the tool name.
 
         Returns:
             bool: True if all commands succeeded, False if any failed.
@@ -242,6 +245,8 @@ def run_topp(self, tool: str, input_output: dict, custom_params: dict = {}) -> b
             ValueError: If the lengths of input/output file lists are inconsistent,
                         except for single string inputs.
         """
+        # Use tool_instance_name for parameter lookup, fall back to tool name
+        params_key = tool_instance_name if tool_instance_name else tool
         # check input: any input lists must be same length, other items can be a single string
         # e.g. input_mzML : [list of n mzML files], output_featureXML : [list of n featureXML files], input_database : database.tsv
         io_lengths = [len(v) for v in input_output.values() if len(v) > 1]
@@ -281,9 +286,9 @@ def run_topp(self, tool: str, input_output: dict, custom_params: dict = {}) -> b
                 # standard case, files was a list of strings, take the file name at index
                 else:
                     command += [value[i]]
-            # Add non-default TOPP tool parameters
-            if tool in params.keys():
-                for k, v in params[tool].items():
+            # Add non-default TOPP tool parameters (use params_key for lookup)
+            if params_key in params.keys():
+                for k, v in params[params_key].items():
                     command += [f"-{k}"]
                     # Skip only empty strings (pass flag with no value)
                     # Note: 0 and 0.0 are valid values, so use explicit check

src/workflow/ParameterManager.py

@@ -65,7 +65,7 @@ def save_parameters(self) -> None:
         # Advanced parameters are only in session state if the view is active
         json_params = self.get_parameters_from_json() | json_params
 
-        # get a list of TOPP tools which are in session state
+        # get a list of TOPP tools (or tool instance names) which are in session state
         current_topp_tools = list(
             set(
                 [
@@ -75,12 +75,16 @@ def save_parameters(self) -> None:
                 ]
             )
         )
-        # for each TOPP tool, open the ini file
+        # Retrieve the instance-name → real-tool-name mapping (set by input_TOPP)
+        tool_instance_map = st.session_state.get("_topp_tool_instance_map", {})
+        # for each TOPP tool (or instance name), open the ini file
         for tool in current_topp_tools:
-            if not self.create_ini(tool):
+            # Resolve instance name to real tool name for create_ini / ini loading
+            real_tool = tool_instance_map.get(tool, tool)
+            if not self.create_ini(real_tool):
                 # Could not create ini file - skip this tool
                 continue
-            ini_path = Path(self.ini_dir, f"{tool}.ini")
+            ini_path = Path(self.ini_dir, f"{real_tool}.ini")
             if tool not in json_params:
                 json_params[tool] = {}
             # load the param object
@@ -92,8 +96,11 @@ def save_parameters(self) -> None:
                     # Skip display keys used by multiselect widgets
                     if key.endswith("_display"):
                         continue
-                    # get ini_key
-                    ini_key = key.replace(self.topp_param_prefix, "").encode()
+                    # get ini_key – map instance name back to real tool name
+                    ini_key = key.replace(self.topp_param_prefix, "")
+                    if tool != real_tool:
+                        ini_key = ini_key.replace(f"{tool}:1:", f"{real_tool}:1:", 1)
+                    ini_key = ini_key.encode()
                     # get ini (default) value by ini_key
                     ini_value = param.getValue(ini_key)
                     is_list_param = isinstance(ini_value, list)
@@ -130,17 +137,20 @@ def get_parameters_from_json(self) -> dict:
                 st.error("**ERROR**: Attempting to load an invalid JSON parameter file. Reset to defaults.")
                 return {}
 
-    def get_topp_parameters(self, tool: str) -> dict:
+    def get_topp_parameters(self, tool: str, tool_instance_name: str = None) -> dict:
         """
         Get all parameters for a TOPP tool, merging defaults with user values.
 
         Args:
-            tool: Name of the TOPP tool (e.g., "CometAdapter")
+            tool: Name of the TOPP tool executable (e.g., "CometAdapter")
+            tool_instance_name: Optional instance name used for parameter storage
+                (e.g., "IDFilter_step1"). If not provided, defaults to tool name.
 
         Returns:
             Dict with parameter names as keys (without tool prefix) and their values.
             Returns empty dict if ini file doesn't exist.
         """
+        instance_name = tool_instance_name or tool
         ini_path = Path(self.ini_dir, f"{tool}.ini")
         if not ini_path.exists():
             return {}
@@ -158,8 +168,8 @@ def get_topp_parameters(self, tool: str) -> dict:
                 short_key = key_str.split(prefix, 1)[1]
                 full_params[short_key] = param.getValue(key)
 
-        # Override with user-modified values from JSON
-        user_params = self.get_parameters_from_json().get(tool, {})
+        # Override with user-modified values from JSON (keyed by instance name)
+        user_params = self.get_parameters_from_json().get(instance_name, {})
         full_params.update(user_params)
 
         return full_params

src/workflow/StreamlitUI.py

@@ -616,6 +616,7 @@ def input_TOPP(
         display_subsections: bool = True,
         display_subsection_tabs: bool = False,
         custom_defaults: dict = {},
+        tool_instance_name: str = None,
     ) -> None:
         """
         Generates input widgets for TOPP tool parameters dynamically based on the tool's
@@ -631,7 +632,21 @@ def input_TOPP(
             display_subsections (bool, optional): Whether to split parameters into subsections based on the prefix. Defaults to True.
             display_subsection_tabs (bool, optional): Whether to display main subsections in separate tabs (if more than one main section). Defaults to False.
             custom_defaults (dict, optional): Dictionary of custom defaults to use. Defaults to an empty dict.
+            tool_instance_name (str, optional): A unique instance name for this tool
+                invocation. Allows multiple instances of the same TOPP tool with
+                independent parameters (e.g., two IDFilter calls). If not provided,
+                defaults to topp_tool_name. The instance name is used for session
+                state keys and parameter storage, while topp_tool_name is used for
+                the actual tool executable and ini file creation.
         """
+        # Default instance name to the tool name when not provided
+        if tool_instance_name is None:
+            tool_instance_name = topp_tool_name
+
+        # Register instance-name → real-tool-name mapping in session state
+        if "_topp_tool_instance_map" not in st.session_state:
+            st.session_state["_topp_tool_instance_map"] = {}
+        st.session_state["_topp_tool_instance_map"][tool_instance_name] = topp_tool_name
 
         if not display_subsections:
             display_subsection_tabs = False
@@ -735,9 +750,9 @@ def _matches_parameter(pattern: str, key: bytes) -> bool:
         # else check if the parameter is already in self.params, if yes take the value from self.params
         for p in params:
             name = p["key"].decode().split(":1:")[1]
-            if topp_tool_name in self.params:
-                if name in self.params[topp_tool_name]:
-                    p["value"] = self.params[topp_tool_name][name]
+            if tool_instance_name in self.params:
+                if name in self.params[tool_instance_name]:
+                    p["value"] = self.params[tool_instance_name][name]
                 elif name in custom_defaults:
                     p["value"] = custom_defaults[name]
             elif name in custom_defaults:
@@ -775,7 +790,7 @@ def _matches_parameter(pattern: str, key: bytes) -> bool:
 
         # Display tool name if required
         if display_tool_name:
-            st.markdown(f"**{topp_tool_name}**")
+            st.markdown(f"**{tool_instance_name}**")
 
         tab_names = [k for k in param_sections.keys() if ":" not in k]
         tabs = None
@@ -803,8 +818,11 @@ def display_TOPP_params(params: dict, num_cols):
             cols = st.columns(num_cols)
             i = 0
             for p in params:
-                # get key and name
-                key = f"{self.parameter_manager.topp_param_prefix}{p['key'].decode()}"
+                # get key and name – use tool_instance_name in session state key
+                key_str = p['key'].decode()
+                if tool_instance_name != topp_tool_name:
+                    key_str = key_str.replace(f"{topp_tool_name}:1:", f"{tool_instance_name}:1:", 1)
+                key = f"{self.parameter_manager.topp_param_prefix}{key_str}"
                 name = p["name"]
                 try:
                     # sometimes strings with newline, handle as list