Update app.py

app.py

@@ -303,26 +303,18 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                 # Add button updates in a consistent order (e.g., order of plot_configs)
                 for cfg in plot_configs:
                     p_id = cfg["id"]
-                    if p_id in plot_ui_objects:
-                        # Append updates for bomb, explore, formula buttons for this plot_id
-                        # Ensure explore button is handled by its own handler or reset here if needed
+                    if p_id in plot_ui_objects: # Check if plot_id exists in UI objects
                         if plot_ui_objects[p_id]["bomb_button"] in button_updates:
                             final_updates.append(button_updates[plot_ui_objects[p_id]["bomb_button"]])
-                        else: # Default reset if not specifically handled
+                        else: 
                             final_updates.append(gr.update(value=BOMB_ICON))
                         
-                        # Explore button is handled separately, but ensure it's in the output list
-                        # For now, we'll let its own handler manage its state, or reset it if another action occurs.
-                        # This part needs careful thought for interactions between explore and other actions.
-                        # Let's assume for now that activating insights/formula doesn't auto-close explore.
-                        # We will need to add explore_button to the output list.
-                        # For now, this handler focuses on insights/formula buttons.
-                        # We'll need to expand the output list.
-
                         if plot_ui_objects[p_id]["formula_button"] in button_updates:
                             final_updates.append(button_updates[plot_ui_objects[p_id]["formula_button"]])
-                        else: # Default reset
+                        else: 
                             final_updates.append(gr.update(value=FORMULA_ICON))
+                    else: # Should not happen if plot_ui_objects is complete
+                        final_updates.extend([gr.update(), gr.update()]) # Add empty updates to maintain length
                 
                 return final_updates
 
@@ -330,8 +322,8 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
             def handle_explore_click(plot_id_clicked, current_explored_plot_id):
                 logging.info(f"Explore clicked for: {plot_id_clicked}. Currently explored: {current_explored_plot_id}")
                 
-                panel_visibility_updates = {} # {panel_component: gr.update}
-                button_icon_updates = {}    # {button_component: gr.update}
+                panel_visibility_updates = {} 
+                button_icon_updates = {}    
                 new_explored_id = None
 
                 is_toggling_off = (plot_id_clicked == current_explored_plot_id)
@@ -343,98 +335,104 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                 else:
                     new_explored_id = plot_id_clicked
                     button_icon_updates[plot_ui_objects[plot_id_clicked]["explore_button"]] = gr.update(value=ACTIVE_ICON)
-                    # If another plot was explored, reset its button
                     if current_explored_plot_id and current_explored_plot_id != plot_id_clicked:
                         button_icon_updates[plot_ui_objects[current_explored_plot_id]["explore_button"]] = gr.update(value=EXPLORE_ICON)
                     logging.info(f"Exploring plot: {plot_id_clicked}")
                 
-                # Determine visibility for all panels
                 for i in range(0, len(plot_configs), 2):
                     config1_id = plot_configs[i]["id"]
+                    if config1_id not in plot_ui_objects: continue # Skip if panel doesn't exist
                     panel1 = plot_ui_objects[config1_id]["panel_component"]
                     
-                    show_panel1 = True
-                    if new_explored_id: # If any plot is explored
-                        show_panel1 = (config1_id == new_explored_id)
+                    show_panel1 = not new_explored_id or (config1_id == new_explored_id)
                     panel_visibility_updates[panel1] = gr.update(visible=show_panel1)
 
                     if i + 1 < len(plot_configs):
                         config2_id = plot_configs[i+1]["id"]
-                        # Only process second panel if it's in the same section as the first
+                        if config2_id not in plot_ui_objects: continue # Skip if panel doesn't exist
+
                         if plot_configs[i+1]["section"] == plot_configs[i]["section"]:
                             panel2 = plot_ui_objects[config2_id]["panel_component"]
-                            show_panel2 = True
-                            if new_explored_id: # If any plot is explored
-                                show_panel2 = (config2_id == new_explored_id)
-                            # If panel1 is explored, panel2 in the same row should be hidden unless panel2 is the one being explored
-                            if config1_id == new_explored_id and config2_id != new_explored_id :
-                                show_panel2 = False
-                            elif config2_id == new_explored_id and config1_id != new_explored_id:
-                                show_panel1 = False # Re-evaluate panel1 if panel2 is explored
-                                panel_visibility_updates[panel1] = gr.update(visible=show_panel1)
-
-
+                            show_panel2 = not new_explored_id or (config2_id == new_explored_id)
+                            
+                            if new_explored_id: # If a plot is being explored
+                                if config1_id == new_explored_id: show_panel2 = False # Hide sibling if first is explored
+                                elif config2_id == new_explored_id: show_panel1 = False # Hide sibling if second is explored
+                            
+                            panel_visibility_updates[panel1] = gr.update(visible=show_panel1) # Re-update panel1 if changed
                             panel_visibility_updates[panel2] = gr.update(visible=show_panel2)
-                        # else: panel2 is in a new section, will be handled when its turn comes as config1_id
 
-                # Construct final updates list
-                # Order: explored_plot_id_state, then all panel visibility, then all explore button icons
                 final_updates = [new_explored_id]
                 for cfg in plot_configs:
                     p_id = cfg["id"]
                     if p_id in plot_ui_objects:
                         panel = plot_ui_objects[p_id]["panel_component"]
-                        final_updates.append(panel_visibility_updates.get(panel, gr.update())) # Default no change if not in updates
+                        final_updates.append(panel_visibility_updates.get(panel, gr.update(visible=not new_explored_id or (p_id == new_explored_id) ))) 
                         
                         explore_btn = plot_ui_objects[p_id]["explore_button"]
-                        final_updates.append(button_icon_updates.get(explore_btn, gr.update(value=EXPLORE_ICON))) # Default to original icon
+                        final_updates.append(button_icon_updates.get(explore_btn, gr.update(value=EXPLORE_ICON if p_id != new_explored_id else ACTIVE_ICON)))
+                    else: # Should not happen
+                        final_updates.extend([gr.update(), gr.update()])
                 
                 return final_updates
 
             # --- Connect Action Buttons ---
-            # Outputs for Insights/Formula: global_actions_column_ui, global_actions_markdown_ui, active_panel_action_state, + all bomb_buttons, + all formula_buttons
             action_buttons_outputs = [
                 global_actions_column_ui, 
                 global_actions_markdown_ui, 
                 active_panel_action_state
             ]
-            # Add all bomb and formula buttons to the output list for icon updates
             for cfg in plot_configs:
                 pid = cfg["id"]
-                if pid in plot_ui_objects:
+                if pid in plot_ui_objects: # Important check
                     action_buttons_outputs.append(plot_ui_objects[pid]["bomb_button"])
                     action_buttons_outputs.append(plot_ui_objects[pid]["formula_button"])
-            
-            # Outputs for Explore: explored_plot_id_state, + all panel_components, + all explore_buttons
+                else: # Maintain list length if a plot_ui_object is unexpectedly missing
+                    action_buttons_outputs.extend([None, None]) # This could cause issues if None is not handled by Gradio outputs
+
             explore_buttons_outputs = [explored_plot_id_state]
             for cfg in plot_configs:
                 pid = cfg["id"]
-                if pid in plot_ui_objects:
+                if pid in plot_ui_objects: # Important check
                     explore_buttons_outputs.append(plot_ui_objects[pid]["panel_component"])
                     explore_buttons_outputs.append(plot_ui_objects[pid]["explore_button"])
+                else: # Maintain list length
+                    explore_buttons_outputs.extend([None, None])
 
 
             for config_item in plot_configs:
                 plot_id = config_item["id"]
-                if plot_id in plot_ui_objects:
+                if plot_id in plot_ui_objects: # Ensure component exists before trying to attach event
                     ui_obj = plot_ui_objects[plot_id]
                     
+                    current_action_outputs = [
+                        global_actions_column_ui, 
+                        global_actions_markdown_ui, 
+                        active_panel_action_state
+                    ] + [plot_ui_objects[c["id"]]["bomb_button"] for c in plot_configs if c["id"] in plot_ui_objects] \
+                      + [plot_ui_objects[c["id"]]["formula_button"] for c in plot_configs if c["id"] in plot_ui_objects]
+
+                    current_explore_outputs = [explored_plot_id_state] \
+                                            + [plot_ui_objects[c["id"]]["panel_component"] for c in plot_configs if c["id"] in plot_ui_objects] \
+                                            + [plot_ui_objects[c["id"]]["explore_button"] for c in plot_configs if c["id"] in plot_ui_objects]
+
+
                     ui_obj["bomb_button"].click(
-                        fn=lambda p_id=plot_id: handle_panel_action(p_id, "insights", active_panel_action_state.value, token_state.value), # Use .value for state in lambda
-                        inputs=None, # Inputs are passed via lambda closure and state.value
-                        outputs=action_buttons_outputs,
+                        fn=lambda p_id=plot_id: handle_panel_action(p_id, "insights", active_panel_action_state.value, token_state.value), 
+                        inputs=None, 
+                        outputs=current_action_outputs, # Use dynamically scoped list
                         api_name=f"action_insights_{plot_id}"
                     )
                     ui_obj["formula_button"].click(
                         fn=lambda p_id=plot_id: handle_panel_action(p_id, "formula", active_panel_action_state.value, token_state.value),
                         inputs=None,
-                        outputs=action_buttons_outputs,
+                        outputs=current_action_outputs, # Use dynamically scoped list
                         api_name=f"action_formula_{plot_id}"
                     )
                     ui_obj["explore_button"].click(
                         fn=lambda p_id=plot_id: handle_explore_click(p_id, explored_plot_id_state.value),
                         inputs=None,
-                        outputs=explore_buttons_outputs,
+                        outputs=current_explore_outputs, # Use dynamically scoped list
                         api_name=f"action_explore_{plot_id}"
                     )
 
@@ -448,9 +446,8 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                 status_message_update = plot_generation_results[0]
                 generated_plot_figures = plot_generation_results[1:]
 
-                all_updates = [status_message_update] # For analytics_status_md
+                all_updates = [status_message_update] 
 
-                # Plot figure updates
                 for i, config in enumerate(plot_configs):
                     p_id_key = config["id"]
                     if p_id_key in plot_ui_objects:
@@ -459,43 +456,43 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                         else:
                             all_updates.append(create_placeholder_plot("Figure Error", f"No figure for {p_id_key}"))
                     else:
-                         all_updates.append(None) # Placeholder if UI object doesn't exist
+                         all_updates.append(None) 
 
-                # Reset Global Action Column
                 all_updates.append(gr.update(visible=False)) 
                 all_updates.append(gr.update(value="Click a button (💣, ƒ) on a plot...")) 
-                all_updates.append(None) # Reset active_panel_action_state
+                all_updates.append(None) 
                 
-                # Reset all button icons (bomb, formula, explore) and panel visibility for explore
                 for cfg in plot_configs:
                     pid = cfg["id"]
                     if pid in plot_ui_objects:
-                        all_updates.append(gr.update(value=BOMB_ICON))    # bomb_button
-                        all_updates.append(gr.update(value=FORMULA_ICON)) # formula_button
-                        all_updates.append(gr.update(value=EXPLORE_ICON)) # explore_button
-                        all_updates.append(gr.update(visible=True))       # panel_component (for explore reset)
-                    else: # Add placeholders if UI object doesn't exist to keep list length
+                        all_updates.append(gr.update(value=BOMB_ICON))    
+                        all_updates.append(gr.update(value=FORMULA_ICON)) 
+                        all_updates.append(gr.update(value=EXPLORE_ICON)) 
+                        all_updates.append(gr.update(visible=True))       
+                    else: 
                         all_updates.extend([None,None,None,None])
 
 
-                all_updates.append(None) # Reset explored_plot_id_state
+                all_updates.append(None) 
                 
                 logging.info(f"Prepared {len(all_updates)} updates for analytics refresh.")
                 return all_updates
 
             # --- Define outputs for the apply_filter_btn and sync.then() ---
             apply_filter_and_sync_outputs = [analytics_status_md]
-            for config in plot_configs: # Plot components
+            for config in plot_configs: 
                 pid = config["id"]
-                apply_filter_and_sync_outputs.append(plot_ui_objects[pid]["plot_component"] if pid in plot_ui_objects else None)
+                if pid in plot_ui_objects and "plot_component" in plot_ui_objects[pid]:
+                    apply_filter_and_sync_outputs.append(plot_ui_objects[pid]["plot_component"])
+                else:
+                    apply_filter_and_sync_outputs.append(None) # Must add placeholder if component might be missing
             
-            apply_filter_and_sync_outputs.extend([ # Global action column and its state
+            apply_filter_and_sync_outputs.extend([ 
                 global_actions_column_ui, 
                 global_actions_markdown_ui, 
                 active_panel_action_state
             ])
             
-            # Add all button components and panel components for reset
             for cfg in plot_configs:
                 pid = cfg["id"]
                 if pid in plot_ui_objects:
@@ -504,7 +501,9 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                     apply_filter_and_sync_outputs.append(plot_ui_objects[pid]["explore_button"])
                     apply_filter_and_sync_outputs.append(plot_ui_objects[pid]["panel_component"])
                 else:
-                    apply_filter_and_sync_outputs.extend([None,None,None,None])
+                    # This case indicates a mismatch and will likely cause errors if not handled.
+                    # Forcing list length for now, but root cause would be plot_ui_objects incompleteness.
+                    apply_filter_and_sync_outputs.extend([None, None, None, None])
 
 
             apply_filter_and_sync_outputs.append(explored_plot_id_state)