Update ui_generators.py

ui_generators.py

@@ -322,112 +322,126 @@ def run_follower_stats_tab_display(token_state):
     follower_html_output = "\n".join(html_parts)
     return follower_html_output, plot_monthly_gains, plot_seniority_dist, plot_industry_dist
 
-
-# --- UI GENERATION LOGIC FOR ANALYTICS TAB ---
 def create_analytics_plot_panel(plot_label_str, plot_id_str):
     """
     Creates an individual plot panel with its plot component and action buttons.
+    This version matches the original structure provided by the user.
     Returns the panel (Column), plot component, and button components.
     """
-    with gr.Column(visible=True) as panel_component: # Main container for this plot
-        with gr.Row(variant="compact"):
-            gr.Markdown(f"#### {plot_label_str}") # Plot title
-            with gr.Row(elem_classes="plot-actions", scale=0): # Action buttons container
-                # Ensure icons are defined (e.g., BOMB_ICON, EXPLORE_ICON, FORMULA_ICON)
-                # If not defined globally, pass them or use placeholders
-                bomb_button = gr.Button(value="💣", variant="tool", size="sm", min_width=30, elem_id=f"bomb_btn_{plot_id_str}")
-                formula_button = gr.Button(value="ƒ", variant="tool", size="sm", min_width=30, elem_id=f"formula_btn_{plot_id_str}")
-                explore_button = gr.Button(value="🧭", variant="tool", size="sm", min_width=30, elem_id=f"explore_btn_{plot_id_str}")
-        
-        # Placeholder for the actual plot - this will be updated by the analytics generation logic
-        plot_component = gr.Plot(label=plot_label_str, show_label=False) 
-        # Example of adding some specific styling or structure if needed
-        # gr.HTML(f"<div class='plot-container' id='plot_container_{plot_id_str}'></div>") # If you were embedding plots differently
+    # Values for BOMB_ICON, EXPLORE_ICON, FORMULA_ICON should be sourced from where they are defined,
+    # e.g., imported from config or passed as arguments if they vary.
+    # For consistency with app.py, let's assume they are globally accessible or correctly imported.
+    # If not, replace "BOMB_ICON", "EXPLORE_ICON", "FORMULA_ICON" with their actual string values like "�".
+    # This function will use string literals for icons if not found in global scope,
+    # but it's better practice to ensure they are consistently defined.
+    try:
+        from config import BOMB_ICON, EXPLORE_ICON, FORMULA_ICON # Try to import if they are in config
+    except ImportError:
+        logging.warning("Icons BOMB_ICON, EXPLORE_ICON, FORMULA_ICON not found in config, using defaults.")
+        BOMB_ICON = "💣"
+        EXPLORE_ICON = "🧭"
+        FORMULA_ICON = "ƒ"
 
-    logging.debug(f"Created analytics panel for: {plot_label_str} (ID: {plot_id_str})")
-    return panel_component, plot_component, bomb_button, explore_button, formula_button
+
+    with gr.Column() as panel_col: 
+        with gr.Row(equal_height=False, variant="panel"): 
+            plot_component = gr.Plot(label=plot_label_str, scale=8, show_label=True) # Ensure plot label is shown
+            with gr.Column(scale=2, min_width=100): 
+                bomb_button = gr.Button(BOMB_ICON, variant="secondary", size="sm", elem_id=f"bomb_{plot_id_str}")
+                explore_button = gr.Button(EXPLORE_ICON, variant="secondary", size="sm", elem_id=f"explore_{plot_id_str}")
+                formula_button = gr.Button(FORMULA_ICON, variant="secondary", size="sm", elem_id=f"formula_{plot_id_str}")
+    logging.debug(f"Created analytics panel for: {plot_label_str} (ID: {plot_id_str}) using original structure.")
+    return panel_col, plot_component, bomb_button, explore_button, formula_button
 
 
 def build_analytics_tab_plot_area(plot_configs):
     """
-    Builds the main plot area for the Analytics tab, arranging plot panels into rows of two.
+    Builds the main plot area for the Analytics tab, arranging plot panels into rows of two,
+    with section titles appearing before their respective plots.
     
     Returns a tuple:
         - plot_ui_objects (dict): Dictionary of plot UI objects.
         - section_titles_map (dict): Dictionary mapping section names to their gr.Markdown title components.
     """
-    logging.info(f"Building plot area for {len(plot_configs)} analytics plots.")
+    logging.info(f"Building plot area for {len(plot_configs)} analytics plots with interleaved section titles.")
     plot_ui_objects = {}
-    section_titles_map = {} # NEW: To store section title Markdown components
-    
-    current_section_title = ""
+    section_titles_map = {} 
     
-    # Determine unique sections in order to correctly create Markdown components for them
-    # This ensures that section_titles_map will have keys for all sections defined in plot_configs
-    # and that they are created in the UI in the correct order.
+    last_rendered_section = None # Keep track of the last section title rendered
     
-    # First pass to create all section title Markdown objects and store them
-    # This is to ensure they are Gradio components that can be targeted for visibility updates.
-    # We use a temporary list to hold sections already processed to avoid duplicate Markdown objects for the same section.
-    processed_sections_for_md_creation = []
-    for config in plot_configs:
-        section_name = config["section"]
-        if section_name not in processed_sections_for_md_creation:
-            # Create the Markdown component for the section title
-            # The actual rendering order will be handled in the layout loop below
-            section_md_component = gr.Markdown(f"### {section_name}", visible=True) # Initially visible
-            section_titles_map[section_name] = section_md_component
-            processed_sections_for_md_creation.append(section_name)
-            logging.debug(f"Created Markdown component for section title: {section_name}")
-
-    # Layout loop: Iterate through plot_configs to place section titles and plot panels
-    i = 0
-    last_rendered_section_title = None # Keep track of the last section title that was actually rendered
-    
-    while i < len(plot_configs):
-        config1 = plot_configs[i]
+    idx = 0
+    while idx < len(plot_configs):
+        current_plot_config = plot_configs[idx]
+        current_section_name = current_plot_config["section"]
         
-        # Render the section title if it's a new section and hasn't been rendered yet in this layout pass
-        if config1["section"] != last_rendered_section_title:
-            current_section_title = config1["section"]
-            
-            last_rendered_section_title = current_section_title
-            logging.info(f"Processing section: {current_section_title}")
-
-
-        # Create row for one or two plot panels
+        # If this plot belongs to a new section, display the section title
+        if current_section_name != last_rendered_section:
+            if current_section_name not in section_titles_map:
+                # Create the Markdown component for this section title if it doesn't exist
+                # This call to gr.Markdown() places it in the current layout flow.
+                section_md_component = gr.Markdown(f"### {current_section_name}", visible=True)
+                section_titles_map[current_section_name] = section_md_component
+                logging.debug(f"Rendered and stored Markdown for section: {current_section_name}")
+            else:
+                # If it exists, it means this section might have appeared before (e.g., non-contiguous sections in plot_configs)
+                # We need to ensure this existing component is "placed" again in the layout.
+                # In Gradio, re-referencing the component variable usually does this.
+                # This line might be needed if section_titles_map[current_section_name] was defined in a way that its
+                # previous rendering doesn't automatically carry to this new layout position.
+                # However, since we are iterating and creating if not exists, this branch might be less common
+                # if plot_configs are typically ordered by section.
+                # For safety, ensure it's visible.
+                section_titles_map[current_section_name].visible = True # Ensure it's visible
+                # section_titles_map[current_section_name] # Re-introduce to layout - often implicit
+                logging.debug(f"Re-using Markdown for section: {current_section_name}")
+
+            last_rendered_section = current_section_name
+
+        # Create a new row for the plot(s)
         with gr.Row(equal_height=False):
+            # --- Process the first plot in the row (config1) ---
+            config1 = plot_configs[idx]
+            # Ensure it's from the current section we just titled (should be, due to loop structure)
+            if config1["section"] != current_section_name:
+                # This case should ideally not happen if logic is correct, means we might have skipped a section title
+                logging.warning(f"Plot {config1['id']} is in section {config1['section']} but current rendered section is {current_section_name}. Layout might be off.")
+                # Force rendering the correct section title if missed
+                if config1["section"] not in section_titles_map:
+                    sec_md = gr.Markdown(f"### {config1['section']}", visible=True)
+                    section_titles_map[config1["section"]] = sec_md
+                last_rendered_section = config1["section"] # Update tracker
+
             panel_col1, plot_comp1, bomb_btn1, explore_btn1, formula_btn1 = \
                 create_analytics_plot_panel(config1["label"], config1["id"])
             plot_ui_objects[config1["id"]] = {
                 "plot_component": plot_comp1, "bomb_button": bomb_btn1,
                 "explore_button": explore_btn1, "formula_button": formula_btn1,
                 "label": config1["label"], "panel_component": panel_col1,
-                "section": config1["section"] # Store section for easier lookup
+                "section": config1["section"]
             }
-            logging.debug(f"Created UI panel for plot_id: {config1['id']}")
-            i += 1
+            logging.debug(f"Created UI panel for plot_id: {config1['id']} in section {config1['section']}")
+            idx += 1
             
-            if i < len(plot_configs):
-                config2 = plot_configs[i]
+            # --- Process the second plot in the row (config2), if applicable ---
+            if idx < len(plot_configs):
+                config2 = plot_configs[idx]
                 # Check if the next plot is in the SAME section to place it in the same row
-                if config2["section"] == current_section_title:
+                if config2["section"] == current_section_name:
                     panel_col2, plot_comp2, bomb_btn2, explore_btn2, formula_btn2 = \
                         create_analytics_plot_panel(config2["label"], config2["id"])
                     plot_ui_objects[config2["id"]] = {
                         "plot_component": plot_comp2, "bomb_button": bomb_btn2,
                         "explore_button": explore_btn2, "formula_button": formula_btn2,
                         "label": config2["label"], "panel_component": panel_col2,
-                        "section": config2["section"] # Store section
+                        "section": config2["section"]
                     }
-                    logging.debug(f"Created UI panel for plot_id: {config2['id']} in same row")
-                    i += 1
-                # If config2 is in a different section, it will be handled by the next iteration of the outer loop
-                # which will then print its own section title.
+                    logging.debug(f"Created UI panel for plot_id: {config2['id']} in same row, section {config2['section']}")
+                    idx += 1
+                # If config2 is in a different section, the outer while loop will handle its title
+                # before creating its panel in a new row.
     
     logging.info(f"Finished building plot area. Total plot objects: {len(plot_ui_objects)}. Section titles created: {len(section_titles_map)}")
     if len(plot_ui_objects) != len(plot_configs):
         logging.error(f"MISMATCH: Expected {len(plot_configs)} plot objects, but created {len(plot_ui_objects)}.")
     
-    # Return both the plot UI objects and the map of section title components
     return plot_ui_objects, section_titles_map