Update app.py

app.py

@@ -3,60 +3,58 @@ import gradio as gr
 import pandas as pd
 import os
 import logging
+from collections import defaultdict
 import matplotlib
 matplotlib.use('Agg') # Set backend for Matplotlib
-import matplotlib.pyplot as plt
-import time
-from datetime import datetime, timedelta
-import numpy as np
-from collections import OrderedDict, defaultdict # Added defaultdict
-import asyncio
 
 # --- Module Imports ---
 from utils.gradio_utils import get_url_user_token
 
 # Functions from newly created/refactored modules
 from config import (
-    LINKEDIN_CLIENT_ID_ENV_VAR, BUBBLE_APP_NAME_ENV_VAR,
-    BUBBLE_API_KEY_PRIVATE_ENV_VAR, BUBBLE_API_ENDPOINT_ENV_VAR,
-    PLOT_ID_TO_FORMULA_KEY_MAP # Keep this if used by AnalyticsTab
+    PLOT_ID_TO_FORMULA_KEY_MAP,
+    LINKEDIN_CLIENT_ID_ENV_VAR,
+    BUBBLE_APP_NAME_ENV_VAR,
+    BUBBLE_API_KEY_PRIVATE_ENV_VAR,
+    BUBBLE_API_ENDPOINT_ENV_VAR
 )
-from services.state_manager import process_and_store_bubble_token
-from services.sync_logic import sync_all_linkedin_data_orchestrator
+# UPDATED: Using the new data loading function from the refactored state manager
+from services.state_manager import load_data_from_bubble
 from ui.ui_generators import (
     display_main_dashboard,
-    build_analytics_tab_plot_area, # This will be passed to AnalyticsTab
-    BOMB_ICON, EXPLORE_ICON, FORMULA_ICON, ACTIVE_ICON # These will be passed
+    build_analytics_tab_plot_area,
+    BOMB_ICON, EXPLORE_ICON, FORMULA_ICON, ACTIVE_ICON
 )
-from ui.analytics_plot_generator import update_analytics_plots_figures, create_placeholder_plot # Pass these
-from formulas import PLOT_FORMULAS # Keep this if used by AnalyticsTab
+from ui.analytics_plot_generator import update_analytics_plots_figures, create_placeholder_plot
+from formulas import PLOT_FORMULAS
 
-# --- EXISTING CHATBOT MODULE IMPORTS ---
-from features.chatbot.chatbot_prompts import get_initial_insight_prompt_and_suggestions # Pass this
-from features.chatbot.chatbot_handler import generate_llm_response # Pass this
+# --- CHATBOT MODULE IMPORTS ---
+from features.chatbot.chatbot_prompts import get_initial_insight_prompt_and_suggestions
+from features.chatbot.chatbot_handler import generate_llm_response
 
-# --- NEW AGENTIC PIPELINE IMPORTS ---
+# --- AGENTIC PIPELINE (DISPLAY ONLY) IMPORTS ---
 try:
-    from run_agentic_pipeline import run_agentic_pipeline_autonomously
-    from ui.insights_ui_generator import (
-        format_single_okr_for_display
-    )
+    # UPDATED: Using the new display function to show pre-computed results
+    from run_agentic_pipeline import load_and_display_agentic_results
+    from ui.insights_ui_generator import format_single_okr_for_display
     AGENTIC_MODULES_LOADED = True
-except:
-    logging.error(f"Could not import agentic pipeline modules: {e}. Tabs 3 and 4 will be disabled.")
+except ImportError as e:
+    logging.error(f"Could not import agentic pipeline display modules: {e}. Tabs 3 and 4 will be disabled.")
     AGENTIC_MODULES_LOADED = False
-    def format_single_okr_for_display(okr_data, **kwargs): return "Agentic modules not loaded. OKR display unavailable." # Placeholder
-
+    # Placeholder for the new function name if imports fail
+    def load_and_display_agentic_results(*args, **kwargs):
+        # This tuple matches the expected number of outputs for the event handler
+        return "Modules not loaded.", "Modules not loaded.", "Modules not loaded.", None, [], [], "Error"
+    def format_single_okr_for_display(okr_data, **kwargs):
+        return "Agentic modules not loaded. OKR display unavailable."
 
-
-# --- IMPORT THE NEW ANALYTICS TAB MODULE ---
-from services.analytics_tab_module import AnalyticsTab # Assuming analytics_tab_module.py is in the services directory
+# --- ANALYTICS TAB MODULE IMPORT ---
+from services.analytics_tab_module import AnalyticsTab
 
 # Configure logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(module)s - %(message)s')
 
 # API Key Setup
-os.environ["GOOGLE_GENAI_USE_VERTEXAI"] = "False"
 user_provided_api_key = os.environ.get("GEMINI_API_KEY")
 if user_provided_api_key:
     os.environ["GOOGLE_API_KEY"] = user_provided_api_key
@@ -66,45 +64,50 @@ else:
 
 
 with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
-                title="LinkedIn Organization Dashboard") as app:
+               title="LinkedIn Organization Dashboard") as app:
+    # --- STATE MANAGEMENT ---
     token_state = gr.State(value={
         "token": None, "client_id": None, "org_urn": None,
         "bubble_posts_df": pd.DataFrame(), "bubble_post_stats_df": pd.DataFrame(),
-        "bubble_mentions_df": pd.DataFrame(),
-        "bubble_follower_stats_df": pd.DataFrame(),
-        "fetch_count_for_api": 0, "url_user_token_temp_storage": None,
+        "bubble_mentions_df": pd.DataFrame(), "bubble_follower_stats_df": pd.DataFrame(),
+        "bubble_agentic_analysis_data": pd.DataFrame(), # To store agentic results from Bubble
+        "url_user_token_temp_storage": None,
+        # Config values remain useful for display components
         "config_date_col_posts": "published_at", "config_date_col_mentions": "date",
         "config_date_col_followers": "date", "config_media_type_col": "media_type",
         "config_eb_labels_col": "li_eb_label"
     })
 
-    # States for existing analytics tab chatbot - these are passed to AnalyticsTab
+    # States for analytics tab chatbot
     chat_histories_st = gr.State({})
     current_chat_plot_id_st = gr.State(None)
-    plot_data_for_chatbot_st = gr.State({}) # This will be populated by the analytics module's refresh
+    plot_data_for_chatbot_st = gr.State({})
 
-    # --- STATES FOR AGENTIC PIPELINE ---
-    orchestration_raw_results_st = gr.State(None) # Stores the full raw output from the agentic pipeline
-    key_results_for_selection_st = gr.State([]) # Stores the list of dicts for KR selection (label, id, etc.)
-    selected_key_result_ids_st = gr.State([]) # Stores the unique_kr_ids selected in the CheckboxGroup
+    # States for agentic results display
+    orchestration_raw_results_st = gr.State(None) # Stores reconstructed report/OKR dict from Bubble
+    key_results_for_selection_st = gr.State([])   # Stores list of dicts for KR selection
+    selected_key_result_ids_st = gr.State([])     # Stores unique_kr_ids selected by the user
 
+    # --- UI LAYOUT ---
     gr.Markdown("# 🚀 LinkedIn Organization Dashboard")
-    url_user_token_display = gr.Textbox(label="User Token (Nascosto)", interactive=False, visible=False)
-    status_box = gr.Textbox(label="Stato Generale Token LinkedIn", interactive=False, value="Inizializzazione...")
-    org_urn_display = gr.Textbox(label="URN Organizzazione (Nascosto)", interactive=False, visible=False)
+    # Hidden components to receive URL parameters
+    url_user_token_display = gr.Textbox(label="User Token (Hidden)", interactive=False, visible=False)
+    org_urn_display = gr.Textbox(label="Org URN (Hidden)", interactive=False, visible=False)
+    # General status display
+    status_box = gr.Textbox(label="Status", interactive=False, value="Initializing...")
 
+    # Load URL parameters on page load
     app.load(fn=get_url_user_token, inputs=None, outputs=[url_user_token_display, org_urn_display], api_name="get_url_params", show_progress=False)
 
-    def initial_load_sequence(url_token, org_urn_val, current_state):
-        status_msg, new_state, btn_update = process_and_store_bubble_token(url_token, org_urn_val, current_state)
+    # UPDATED: Simplified initial data loading sequence
+    def initial_data_load_sequence(url_token, org_urn_val, current_state):
+        # This function now only loads data from Bubble and updates the main dashboard display
+        status_msg, new_state = load_data_from_bubble(url_token, org_urn_val, current_state)
         dashboard_content = display_main_dashboard(new_state)
-        return status_msg, new_state, btn_update, dashboard_content
+        return status_msg, new_state, dashboard_content
 
-    # --- Instantiate the AnalyticsTab module ---
-    analytics_icons = {
-        'bomb': BOMB_ICON, 'explore': EXPLORE_ICON,
-        'formula': FORMULA_ICON, 'active': ACTIVE_ICON
-    }
+    # Instantiate the AnalyticsTab module (no changes needed here)
+    analytics_icons = {'bomb': BOMB_ICON, 'explore': EXPLORE_ICON, 'formula': FORMULA_ICON, 'active': ACTIVE_ICON}
     analytics_tab_instance = AnalyticsTab(
         token_state=token_state,
         chat_histories_st=chat_histories_st,
@@ -121,56 +124,50 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
     )
 
     with gr.Tabs() as tabs:
-        with gr.TabItem("1️⃣ Dashboard & Sync", id="tab_dashboard_sync"):
-            gr.Markdown("Il sistema controlla i dati esistenti da Bubble. 'Sincronizza' si attiva se sono necessari nuovi dati.")
-            sync_data_btn = gr.Button("🔄 Sincronizza Dati LinkedIn", variant="primary", visible=False, interactive=False)
-            sync_status_html_output = gr.HTML("<p style='text-align:center;'>Stato sincronizzazione...</p>")
+        with gr.TabItem("1️⃣ Dashboard", id="tab_dashboard"):
+            # REMOVED: Sync button and related UI components. This tab is now just for the main dashboard.
+            gr.Markdown("I dati visualizzati in questo pannello sono caricati direttamente da Bubble.io.")
             dashboard_display_html = gr.HTML("<p style='text-align:center;'>Caricamento dashboard...</p>")
 
-        # --- Use the AnalyticsTab module to create Tab 2 ---
+        # Use the AnalyticsTab module to create Tab 2
         analytics_tab_instance.create_tab_ui()
 
-        # --- Tab 3: Agentic Analysis Report ---
+        # Tab 3: Agentic Analysis Report
         with gr.TabItem("3️⃣ Agentic Analysis Report", id="tab_agentic_report", visible=AGENTIC_MODULES_LOADED):
-            gr.Markdown("## 🤖 Comprehensive Analysis Report (AI Generated)")
-            agentic_pipeline_status_md = gr.Markdown("Stato Pipeline AI (filtro 'Sempre'): In attesa...", visible=True)
-            gr.Markdown("Questo report è generato da un agente AI con filtro 'Sempre' sui dati disponibili. Rivedi criticamente.")
-            agentic_report_display_md = gr.Markdown("La pipeline AI si avvierà automaticamente dopo il caricamento iniziale dei dati o dopo una sincronizzazione.")
+            gr.Markdown("## 🤖 Comprehensive Analysis Report (from Bubble.io)")
+            agentic_pipeline_status_md = gr.Markdown("Status: Loading report data...", visible=True)
+            gr.Markdown("Questo report è stato pre-generato da un agente AI e caricato da Bubble.io.")
+            agentic_report_display_md = gr.Markdown("The AI-generated report will be displayed here once loaded.")
             if not AGENTIC_MODULES_LOADED:
-                gr.Markdown("🔴 **Error:** Agentic pipeline modules could not be loaded. This tab is disabled.")
+                gr.Markdown("🔴 **Error:** Agentic pipeline display modules could not be loaded. This tab is disabled.")
 
-        # --- Tab 4: Agentic OKRs & Tasks ---
+        # Tab 4: Agentic OKRs & Tasks
         with gr.TabItem("4️⃣ Agentic OKRs & Tasks", id="tab_agentic_okrs", visible=AGENTIC_MODULES_LOADED):
-            gr.Markdown("## 🎯 AI Generated OKRs and Actionable Tasks (filtro 'Sempre')")
-            gr.Markdown("Basato sull'analisi AI (filtro 'Sempre'), l'agente ha proposto i seguenti OKR e task. Seleziona i Key Results per dettagli.")
+            gr.Markdown("## 🎯 AI Generated OKRs and Actionable Tasks (from Bubble.io)")
+            gr.Markdown("Basato sull'analisi AI pre-generata, l'agente ha proposto i seguenti OKR. Seleziona i Key Results per dettagli.")
             if not AGENTIC_MODULES_LOADED:
-                gr.Markdown("🔴 **Error:** Agentic pipeline modules could not be loaded. This tab is disabled.")
+                gr.Markdown("🔴 **Error:** Agentic pipeline display modules could not be loaded. This tab is disabled.")
             with gr.Row():
                 with gr.Column(scale=1):
-                    gr.Markdown("### Suggested Key Results (da analisi 'Sempre')")
+                    gr.Markdown("### Suggested Key Results")
                     key_results_cbg = gr.CheckboxGroup(label="Select Key Results", choices=[], value=[], interactive=True)
                 with gr.Column(scale=3):
                     gr.Markdown("### Detailed OKRs and Tasks for Selected Key Results")
-                    okr_detail_display_md = gr.Markdown("I dettagli OKR appariranno qui dopo l'esecuzione della pipeline AI.")
+                    okr_detail_display_md = gr.Markdown("I dettagli OKR appariranno qui dopo il caricamento dei dati.")
 
+            # This handler logic for the CheckboxGroup remains the same, as it operates on loaded data.
             def update_okr_display_on_selection(selected_kr_unique_ids: list, raw_orchestration_results: dict, all_krs_for_selection: list):
                 if not raw_orchestration_results or not AGENTIC_MODULES_LOADED:
-                    return gr.update(value="Nessun dato dalla pipeline AI o moduli non caricati.")
-
-                actionable_okrs_dict = raw_orchestration_results.get("actionable_okrs_and_tasks")
+                    return gr.update(value="Nessun dato di analisi caricato o moduli non disponibili.")
+                actionable_okrs_dict = raw_orchestration_results.get("actionable_okrs")
                 if not actionable_okrs_dict or not isinstance(actionable_okrs_dict.get("okrs"), list):
-                    return gr.update(value="Nessun OKR trovato nei risultati della pipeline.")
+                    return gr.update(value="Nessun OKR trovato nei dati di analisi caricati.")
 
                 okrs_list = actionable_okrs_dict["okrs"]
-                # Ensure all_krs_for_selection is a list of dicts with expected keys
-                if not all_krs_for_selection or not isinstance(all_krs_for_selection, list) or \
-                   not all(isinstance(kr, dict) and 'unique_kr_id' in kr and 'okr_index' in kr and 'kr_index' in kr for kr in all_krs_for_selection):
-                    logging.error("all_krs_for_selection is not in the expected format.")
+                if not all_krs_for_selection or not isinstance(all_krs_for_selection, list):
                     return gr.update(value="Errore interno: formato dati KR non valido.")
 
-
                 kr_id_to_indices = {kr_info['unique_kr_id']: (kr_info['okr_index'], kr_info['kr_index']) for kr_info in all_krs_for_selection}
-
                 selected_krs_by_okr_idx = defaultdict(list)
                 if selected_kr_unique_ids:
                     for kr_unique_id in selected_kr_unique_ids:
@@ -179,39 +176,26 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                             selected_krs_by_okr_idx[okr_idx].append(kr_idx)
 
                 output_md_parts = []
-                if not okrs_list:
-                    output_md_parts.append("Nessun OKR generato.")
-                else:
-                    for okr_idx, okr_data in enumerate(okrs_list):
-                        accepted_indices_for_this_okr = selected_krs_by_okr_idx.get(okr_idx)
-                        # If specific KRs are selected, only show OKRs that have at least one of the selected KRs
-                        # OR if no KRs are selected at all, show all OKRs.
-                        if selected_kr_unique_ids: # User has made a selection
-                            if accepted_indices_for_this_okr is not None: # This OKR has some of the selected KRs
-                                output_md_parts.append(format_single_okr_for_display(okr_data, accepted_kr_indices=accepted_indices_for_this_okr, okr_main_index=okr_idx))
-                        else: # No KRs selected, show all OKRs with all their KRs
-                            output_md_parts.append(format_single_okr_for_display(okr_data, accepted_kr_indices=None, okr_main_index=okr_idx))
-                
-                if not output_md_parts and selected_kr_unique_ids:
-                    final_md = "Nessun OKR corrisponde alla selezione corrente o i KR selezionati non hanno task dettagliati."
-                elif not output_md_parts and not selected_kr_unique_ids: # Should be covered by "Nessun OKR generato."
-                    final_md = "Nessun OKR generato."
-                else:
-                    final_md = "\n\n---\n\n".join(output_md_parts)
+                for okr_idx, okr_data in enumerate(okrs_list):
+                    if not selected_kr_unique_ids: # Show all if nothing is selected
+                        output_md_parts.append(format_single_okr_for_display(okr_data, accepted_kr_indices=None, okr_main_index=okr_idx))
+                    elif okr_idx in selected_krs_by_okr_idx: # Show only OKRs that have a selected KR
+                        accepted_indices = selected_krs_by_okr_idx.get(okr_idx)
+                        output_md_parts.append(format_single_okr_for_display(okr_data, accepted_kr_indices=accepted_indices, okr_main_index=okr_idx))
+
+                final_md = "\n\n---\n\n".join(output_md_parts) if output_md_parts else "Nessun OKR corrisponde alla selezione corrente."
                 return gr.update(value=final_md)
 
             if AGENTIC_MODULES_LOADED:
                 key_results_cbg.change(
                     fn=update_okr_display_on_selection,
                     inputs=[key_results_cbg, orchestration_raw_results_st, key_results_for_selection_st],
-                    outputs=[okr_detail_display_md],
-                    api_name="update_okr_display_on_selection_module"
+                    outputs=[okr_detail_display_md]
                 )
 
-
-    # Define the output list for the agentic pipeline callbacks
-    # Order: Report MD, KR CBG, OKR Detail MD, RawResults State, SelectedKRIDs State, KRList State, Status MD
-    agentic_pipeline_outputs_list = [
+    # --- EVENT HANDLING (SIMPLIFIED) ---
+    # Define the output list for loading agentic results
+    agentic_display_outputs = [
         agentic_report_display_md,
         key_results_cbg,
         okr_detail_display_md,
@@ -220,16 +204,16 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
         key_results_for_selection_st,
         agentic_pipeline_status_md
     ]
-    agentic_pipeline_inputs = [token_state] # Input for the autonomous run
 
-    # --- Event Handling ---
+    # This is the main event chain that runs when the app loads
     initial_load_event = org_urn_display.change(
-        fn=initial_load_sequence,
+        fn=initial_data_load_sequence,
         inputs=[url_user_token_display, org_urn_display, token_state],
-        outputs=[status_box, token_state, sync_data_btn, dashboard_display_html],
+        outputs=[status_box, token_state, dashboard_display_html],
         show_progress="full"
     )
 
+    # After initial data is loaded, refresh the analytics graphs
     initial_load_event.then(
         fn=analytics_tab_instance._refresh_analytics_graphs_ui,
         inputs=[
@@ -241,65 +225,23 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
         ],
         outputs=analytics_tab_instance.graph_refresh_outputs_list,
         show_progress="full"
+    # Then, load and display the pre-computed agentic results
     ).then(
-        fn=run_agentic_pipeline_autonomously, # Generator function
-        inputs=[token_state, orchestration_raw_results_st, selected_key_result_ids_st, key_results_for_selection_st],
-        outputs=agentic_pipeline_outputs_list,
-        show_progress="minimal" # Use minimal for generators that yield status
-    )
-
-    sync_event_part1 = sync_data_btn.click(
-        fn=sync_all_linkedin_data_orchestrator,
-        inputs=[token_state],
-        outputs=[sync_status_html_output, token_state],
-        show_progress="full"
-    )
-    sync_event_part2 = sync_event_part1.then(
-        fn=process_and_store_bubble_token,
-        inputs=[url_user_token_display, org_urn_display, token_state],
-        outputs=[status_box, token_state, sync_data_btn],
-        show_progress=False
-    )
-    sync_event_part2.then(
-        fn=run_agentic_pipeline_autonomously, # Generator function
+        fn=load_and_display_agentic_results, # UPDATED function call
         inputs=[token_state, orchestration_raw_results_st, selected_key_result_ids_st, key_results_for_selection_st],
-        outputs=agentic_pipeline_outputs_list,
+        outputs=agentic_display_outputs,
         show_progress="minimal"
     )
-    sync_event_part3 = sync_event_part2.then(
-        fn=display_main_dashboard,
-        inputs=[token_state],
-        outputs=[dashboard_display_html],
-        show_progress=False
-    )
-    sync_event_graphs_after_sync = sync_event_part3.then(
-        fn=analytics_tab_instance._refresh_analytics_graphs_ui,
-        inputs=[
-            token_state,
-            analytics_tab_instance.date_filter_selector,
-            analytics_tab_instance.custom_start_date_picker,
-            analytics_tab_instance.custom_end_date_picker,
-            chat_histories_st
-        ],
-        outputs=analytics_tab_instance.graph_refresh_outputs_list,
-        show_progress="full"
-    )
 
 if __name__ == "__main__":
+    # Environment variable checks remain important
     if not os.environ.get(LINKEDIN_CLIENT_ID_ENV_VAR):
-        logging.warning(f"ATTENZIONE: '{LINKEDIN_CLIENT_ID_ENV_VAR}' non impostata.")
+        logging.warning(f"WARNING: '{LINKEDIN_CLIENT_ID_ENV_VAR}' is not set.")
     if not all(os.environ.get(var) for var in [BUBBLE_APP_NAME_ENV_VAR, BUBBLE_API_KEY_PRIVATE_ENV_VAR, BUBBLE_API_ENDPOINT_ENV_VAR]):
-        logging.warning("ATTENZIONE: Una o più variabili d'ambiente Bubble (BUBBLE_APP_NAME, BUBBLE_API_KEY_PRIVATE, BUBBLE_API_ENDPOINT) non sono impostate.")
+        logging.warning("WARNING: One or more Bubble environment variables are not set.")
     if not AGENTIC_MODULES_LOADED:
-        logging.warning("CRITICAL: Agentic pipeline modules failed to load. Tabs 3 and 4 (Agentic Report & OKRs) will be non-functional.")
-    if not os.environ.get("GEMINI_API_KEY"): # Check GEMINI_API_KEY directly as GOOGLE_API_KEY is derived
-        logging.warning("ATTENZIONE: 'GEMINI_API_KEY' non impostata. Questo è necessario per le funzionalità AI, incluse le tab agentiche e il chatbot dei grafici.")
-    
-    try:
-        logging.info(f"Gradio version: {gr.__version__}")
-        logging.info(f"Pandas version: {pd.__version__}")
-        logging.info(f"Matplotlib version: {matplotlib.__version__}, Backend: {matplotlib.get_backend()}")
-    except Exception as e:
-        logging.warning(f"Could not log library versions: {e}")
+        logging.warning("CRITICAL: Agentic pipeline display modules failed to load. Tabs 3 and 4 will be non-functional.")
+    if not os.environ.get("GEMINI_API_KEY"):
+        logging.warning("WARNING: 'GEMINI_API_KEY' is not set. This may be needed for chatbot features.")
 
     app.launch(server_name="0.0.0.0", server_port=int(os.environ.get("PORT", 7860)), debug=True)