fix: use st.rerun() instead of full page reload for presets

Replace streamlit_js_eval page reload with st.rerun() for smoother UX:
- No page flash/flicker
- Scroll position preserved
- Faster (no re-fetching static assets)

Uses "delete-then-rerun" pattern: apply_preset() now deletes session_state
keys instead of setting them, forcing widgets to re-initialize fresh from
params.json. This avoids fragment caching issues.

Changes:
- ParameterManager.apply_preset(): delete keys instead of setting them
- ParameterManager.clear_parameter_session_state(): new helper method
- StreamlitUI: preset_buttons(), "Load default parameters", and "Import
  parameters" now use st.rerun() with st.toast() for feedback
- Removed unused streamlit_js_eval import
- Updated tests for delete-based behavior

https://claude.ai/code/session_01BnipAqTf16J7kJVfnzah2U

Author: claude

src/workflow/ParameterManager.py

@@ -220,10 +220,11 @@ def get_preset_description(self, preset_name: str) -> str:
 
     def apply_preset(self, preset_name: str) -> bool:
         """
-        Apply a preset to the current session state and save to params.json.
+        Apply a preset by updating params.json and clearing relevant session_state keys.
 
-        This method updates session state keys for both TOPP tool parameters and
-        general workflow parameters based on the preset definition.
+        Uses the "delete-then-rerun" pattern: instead of overwriting session_state
+        values (which widgets may not reflect immediately due to fragment caching),
+        we delete the keys so widgets re-initialize fresh from params.json on rerun.
 
         Args:
             preset_name: Name of the preset to apply
@@ -239,6 +240,9 @@ def apply_preset(self, preset_name: str) -> bool:
         # Load existing parameters
         current_params = self.get_parameters_from_json()
 
+        # Collect keys to delete from session_state
+        keys_to_delete = []
+
         for key, value in preset.items():
             # Skip description key
             if key == "_description":
@@ -248,7 +252,7 @@ def apply_preset(self, preset_name: str) -> bool:
                 # Handle general workflow parameters
                 for param_name, param_value in value.items():
                     session_key = f"{self.param_prefix}{param_name}"
-                    st.session_state[session_key] = param_value
+                    keys_to_delete.append(session_key)
                     current_params[param_name] = param_value
             elif isinstance(value, dict) and not key.startswith("_"):
                 # Handle TOPP tool parameters
@@ -257,11 +261,30 @@ def apply_preset(self, preset_name: str) -> bool:
                     current_params[tool_name] = {}
                 for param_name, param_value in value.items():
                     session_key = f"{self.topp_param_prefix}{tool_name}:1:{param_name}"
-                    st.session_state[session_key] = param_value
+                    keys_to_delete.append(session_key)
                     current_params[tool_name][param_name] = param_value
 
-        # Save updated parameters
+        # Delete affected keys from session_state so widgets re-initialize fresh
+        for session_key in keys_to_delete:
+            if session_key in st.session_state:
+                del st.session_state[session_key]
+
+        # Save updated parameters to file
         with open(self.params_file, "w", encoding="utf-8") as f:
             json.dump(current_params, f, indent=4)
 
-        return True
+        return True
+
+    def clear_parameter_session_state(self) -> None:
+        """
+        Clear all parameter-related keys from session_state.
+
+        This forces widgets to re-initialize from params.json or defaults
+        on the next rerun, rather than using potentially stale session_state values.
+        """
+        keys_to_delete = [
+            key for key in list(st.session_state.keys())
+            if key.startswith(self.param_prefix) or key.startswith(self.topp_param_prefix)
+        ]
+        for key in keys_to_delete:
+            del st.session_state[key]

src/workflow/StreamlitUI.py

@@ -12,7 +12,6 @@
 from io import BytesIO
 import zipfile
 from datetime import datetime
-from streamlit_js_eval import streamlit_js_eval
 
 
 from src.common.common import (
@@ -1092,8 +1091,8 @@ def preset_buttons(self, num_cols: int = 4) -> None:
                     use_container_width=True,
                 ):
                     if self.parameter_manager.apply_preset(preset_name):
-                        st.success(f"Applied preset: {preset_name}")
-                        streamlit_js_eval(js_expressions="parent.window.location.reload()")
+                        st.toast(f"Applied preset: {preset_name}")
+                        st.rerun()
                     else:
                         st.error(f"Failed to apply preset: {preset_name}")
             # Start new row if needed
@@ -1120,11 +1119,13 @@ def parameter_section(self, custom_parameter_function) -> None:
         with cols[0]:
             if st.button(
                 "⚠️ Load default parameters",
-                help="Reset paramter section to default.",
+                help="Reset parameter section to default.",
                 use_container_width=True,
             ):
                 self.parameter_manager.reset_to_default_parameters()
-                streamlit_js_eval(js_expressions="parent.window.location.reload()")
+                self.parameter_manager.clear_parameter_session_state()
+                st.toast("Parameters reset to defaults")
+                st.rerun()
         with cols[1]:
             if self.parameter_manager.params_file.exists():
                 with open(self.parameter_manager.params_file, "rb") as f:
@@ -1148,12 +1149,16 @@ def parameter_section(self, custom_parameter_function) -> None:
 
         with cols[2]:
             up = st.file_uploader(
-                "⬆️ Import parameters", help="Reset parameter section to default."
+                "⬆️ Import parameters",
+                help="Import previously exported parameters.",
+                key="param_import_uploader"
             )
             if up is not None:
                 with open(self.parameter_manager.params_file, "w") as f:
                     f.write(up.read().decode("utf-8"))
-                streamlit_js_eval(js_expressions="parent.window.location.reload()")
+                self.parameter_manager.clear_parameter_session_state()
+                st.toast("Parameters imported")
+                st.rerun()
 
     def execution_section(
         self,

tests/test_parameter_presets.py

@@ -182,33 +182,43 @@ def test_get_preset_description_empty_for_nonexistent_preset(self, temp_workflow
 
         assert desc == ""
 
-    def test_apply_preset_updates_session_state(self, temp_workflow_dir, sample_presets, temp_cwd):
-        """Test that apply_preset correctly updates session state."""
+    def test_apply_preset_deletes_session_state_keys(self, temp_workflow_dir, sample_presets, temp_cwd):
+        """Test that apply_preset deletes session_state keys instead of setting them."""
         with open("presets.json", "w") as f:
             json.dump(sample_presets, f)
 
         pm = ParameterManager(temp_workflow_dir)
+
+        # Pre-populate session_state with old values
+        mock_streamlit.session_state[f"{pm.topp_param_prefix}ToolA:1:param1"] = 999.0
+        mock_streamlit.session_state[f"{pm.topp_param_prefix}ToolA:1:param2"] = "old_value"
+        mock_streamlit.session_state[f"{pm.topp_param_prefix}ToolB:1:param3"] = 999
+
         result = pm.apply_preset("Preset A")
 
         assert result is True
 
-        # Check TOPP tool parameters in session state
-        assert mock_streamlit.session_state[f"{pm.topp_param_prefix}ToolA:1:param1"] == 10.0
-        assert mock_streamlit.session_state[f"{pm.topp_param_prefix}ToolA:1:param2"] == "value2"
-        assert mock_streamlit.session_state[f"{pm.topp_param_prefix}ToolB:1:param3"] == 5
+        # Keys should be DELETED (not set to new values) so widgets re-initialize fresh
+        assert f"{pm.topp_param_prefix}ToolA:1:param1" not in mock_streamlit.session_state
+        assert f"{pm.topp_param_prefix}ToolA:1:param2" not in mock_streamlit.session_state
+        assert f"{pm.topp_param_prefix}ToolB:1:param3" not in mock_streamlit.session_state
 
-    def test_apply_preset_handles_general_params(self, temp_workflow_dir, sample_presets, temp_cwd):
-        """Test that apply_preset correctly handles _general parameters."""
+    def test_apply_preset_deletes_general_param_keys(self, temp_workflow_dir, sample_presets, temp_cwd):
+        """Test that apply_preset deletes _general parameter keys from session_state."""
         with open("presets.json", "w") as f:
             json.dump(sample_presets, f)
 
         pm = ParameterManager(temp_workflow_dir)
+
+        # Pre-populate session_state with old value
+        mock_streamlit.session_state[f"{pm.param_prefix}general_param"] = "old_value"
+
         result = pm.apply_preset("Preset B")
 
         assert result is True
 
-        # Check general parameter in session state
-        assert mock_streamlit.session_state[f"{pm.param_prefix}general_param"] == "general_value"
+        # Key should be DELETED so widget re-initializes fresh
+        assert f"{pm.param_prefix}general_param" not in mock_streamlit.session_state
 
     def test_apply_preset_saves_to_params_file(self, temp_workflow_dir, sample_presets, temp_cwd):
         """Test that apply_preset saves parameters to params.json."""
@@ -265,6 +275,33 @@ def test_apply_preset_preserves_existing_params(self, temp_workflow_dir, sample_
         # New params from preset should be added
         assert saved_params["ToolA"]["param1"] == 10.0
 
+    def test_clear_parameter_session_state(self, temp_workflow_dir):
+        """Test that clear_parameter_session_state removes all parameter keys."""
+        pm = ParameterManager(temp_workflow_dir)
+
+        # Add various keys to session_state
+        mock_streamlit.session_state[f"{pm.param_prefix}param1"] = "value1"
+        mock_streamlit.session_state[f"{pm.param_prefix}param2"] = "value2"
+        mock_streamlit.session_state[f"{pm.topp_param_prefix}Tool:1:param"] = 10.0
+        mock_streamlit.session_state["unrelated_key"] = "should_remain"
+
+        pm.clear_parameter_session_state()
+
+        # Parameter keys should be deleted
+        assert f"{pm.param_prefix}param1" not in mock_streamlit.session_state
+        assert f"{pm.param_prefix}param2" not in mock_streamlit.session_state
+        assert f"{pm.topp_param_prefix}Tool:1:param" not in mock_streamlit.session_state
+
+        # Unrelated keys should remain
+        assert mock_streamlit.session_state["unrelated_key"] == "should_remain"
+
+    def test_clear_parameter_session_state_empty(self, temp_workflow_dir):
+        """Test that clear_parameter_session_state handles empty session_state."""
+        pm = ParameterManager(temp_workflow_dir)
+
+        # Should not raise even with no matching keys
+        pm.clear_parameter_session_state()
+
 
 class TestWorkflowNameParameter:
     """Tests for the workflow_name parameter in ParameterManager."""