Update app.py

app.py

@@ -5,207 +5,266 @@ import os
 import logging
 import matplotlib
 matplotlib.use('Agg') # Set backend for Matplotlib to avoid GUI conflicts with Gradio
-# import time # No longer directly used here for profiling
-from datetime import datetime, timedelta
-# import numpy as np # No longer directly used here
-# from collections import OrderedDict, defaultdict # Moved or not needed directly
+# import matplotlib.pyplot as plt # Not directly used in app.py anymore
+import time # For profiling if needed
+# from datetime import datetime, timedelta # Not directly used in app.py
+# import numpy as np # Not directly used in app.py
+# from collections import OrderedDict, defaultdict # Not directly used in app.py
+import asyncio # For async operations
 
 # --- Module Imports ---
 from utils.gradio_utils import get_url_user_token
+
+# Configuration (assuming these exist and are correctly defined)
 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 moved
+    BUBBLE_API_KEY_PRIVATE_ENV_VAR, BUBBLE_API_ENDPOINT_ENV_VAR,
+    # PLOT_ID_TO_FORMULA_KEY_MAP # Used in analytics_handlers
+)
+# from formulas import PLOT_FORMULAS # Used in analytics_handlers
+
+# Services (assuming these exist and are correctly defined)
 from services.state_manager import process_and_store_bubble_token
 from services.sync_logic import sync_all_linkedin_data_orchestrator
-from ui.ui_generators import display_main_dashboard # Other UI generators moved or used internally by new modules
 
-# --- NEW UI MODULE IMPORTS ---
-from ui import analytics_tab
-from ui import agentic_module
+# UI Generators (assuming these exist and are correctly defined)
+from ui.ui_generators import display_main_dashboard #, build_analytics_tab_plot_area, BOMB_ICON, EXPLORE_ICON, FORMULA_ICON, ACTIVE_ICON
 
-# --- EXISTING CHATBOT MODULE IMPORTS (used by analytics_tab) ---
-# from features.chatbot.chatbot_prompts import get_initial_insight_prompt_and_suggestions # Used in analytics_tab
-# from features.chatbot.chatbot_handler import generate_llm_response # Used in analytics_tab
+# Tab Setup UI functions
+from ui.dashboard_sync_tab import setup_dashboard_sync_tab
+from ui.analytics_tab_setup import setup_analytics_tab
+from ui.agentic_report_tab import setup_agentic_report_tab
+from ui.agentic_okrs_tab import setup_agentic_okrs_tab
 
-# --- AGENTIC PIPELINE IMPORTS (used by agentic_module) ---
-# AGENTIC_MODULES_LOADED is handled within agentic_module.py
+# Handler Classes
+from handlers.dashboard_sync_handlers import DashboardSyncHandlers
+from handlers.analytics_handlers import AnalyticsHandlers
+from handlers.agentic_handlers import AgenticHandlers, AGENTIC_MODULES_LOADED as AGENTIC_HANDLERS_MODULES_LOADED
+
+# Check consistency of AGENTIC_MODULES_LOADED
+# This flag is crucial for conditional UI rendering and functionality.
+# The one from AgenticHandlers is based on its own try-except for its specific imports.
+# We might need a global one if app.py itself tries to import agentic modules directly.
+# For now, using the one from AgenticHandlers as it's most relevant to agentic functionality.
+APP_AGENTIC_MODULES_LOADED = AGENTIC_HANDLERS_MODULES_LOADED
 
 # Configure logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(module)s - %(message)s')
 
-# 1. Set Vertex AI usage preference (if applicable)
-os.environ["GOOGLE_GENAI_USE_VERTEXAI"] = "False"
-
-# 2. Get your API key
+# 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
     logging.info("GOOGLE_API_KEY environment variable has been set from GEMINI_API_KEY.")
 else:
-    logging.error(f"CRITICAL ERROR: The API key environment variable 'GEMINI_API_KEY' was not found.")
+    logging.error("CRITICAL ERROR: The API key environment variable 'GEMINI_API_KEY' was not found.")
 
-
-# --- Gradio UI Blocks ---
+# --- Main Gradio Application ---
 with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
-               title="LinkedIn Organization Dashboard") as app:
-    
-    # --- Core States ---
+                title="LinkedIn Organization Dashboard") as app:
+
+    # --- Global States ---
     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(),
+        "bubble_mentions_df": pd.DataFrame(), 
+        "bubble_follower_stats_df": pd.DataFrame(),
         "fetch_count_for_api": 0, "url_user_token_temp_storage": None,
         "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 analytics tab chatbot
+    chat_histories_st = gr.State({}) # Stores chat histories for each plot_id {plot_id: [{"role":"user",...}]}
+    current_chat_plot_id_st = gr.State(None) # ID of the plot currently active in chat
+    plot_data_for_chatbot_st = gr.State({}) # Stores summaries for plots {plot_id: "summary text"}
 
-    # States for analytics tab chatbot (passed to analytics_tab module)
-    chat_histories_st = gr.State({})
-    current_chat_plot_id_st = gr.State(None)
-    plot_data_for_chatbot_st = gr.State({}) # Populated by analytics_tab.handle_refresh_analytics_graphs
-    active_panel_action_state = gr.State(None) # For insights/formula panel
-    explored_plot_id_state = gr.State(None) # For explore plot view
+    # States for analytics tab panel management
+    active_panel_action_state = gr.State(None) # Tracks current active panel e.g. {"plot_id": "X", "type": "insights"}
+    explored_plot_id_state = gr.State(None) # Tracks if a plot is being "explored" (others hidden)
 
-    # States for Agentic Pipeline (passed to agentic_module)
-    orchestration_raw_results_st = gr.State(None)
-    key_results_for_selection_st = gr.State([]) # Stores the list of dicts for choices
-    selected_key_result_ids_st = gr.State([]) # Stores the selected unique_kr_ids
+    # States for Agentic Pipeline
+    orchestration_raw_results_st = gr.State(None) # Stores raw output from run_full_analytics_orchestration
+    key_results_for_selection_st = gr.State([]) # Stores list of dicts for KR checkbox group choices
+    selected_key_result_ids_st = gr.State([]) # Stores list of selected KR unique IDs from checkbox group (though CBG value is source of truth)
 
-    # --- Top Level UI ---
+    # --- Hidden Components for URL Params ---
     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)
 
-    # Load URL parameters on app load
+    # --- Load URL parameters ---
+    # This runs on app load to fetch params from the URL query string
     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)
 
-    # --- Tabs ---
+    # --- UI Setup for Tabs ---
     with gr.Tabs() as tabs:
-        # --- Tab 1: Dashboard & Sync ---
         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>")
-            dashboard_display_html = gr.HTML("<p style='text-align:center;'>Caricamento dashboard...</p>")
+            dashboard_sync_components = setup_dashboard_sync_tab()
 
-        # --- Tab 2: Analisi Grafici ---
         with gr.TabItem("2️⃣ Analisi Grafici", id="tab_analytics"):
-            # Build UI and wire internal events within analytics_tab module
-            (apply_filter_btn_analytics, date_filter_selector_analytics, 
-             custom_start_date_picker_analytics, custom_end_date_picker_analytics,
-             analytics_status_md_ref, # Reference to the status markdown in analytics tab
-             analytics_refresh_outputs_components, # list of components for refresh handler output
-             analytics_refresh_outputs_plus_states # list of components + states for refresh handler output
-            ) = analytics_tab.build_and_wire_tab(
-                token_state, chat_histories_st, current_chat_plot_id_st, 
-                plot_data_for_chatbot_st, active_panel_action_state, explored_plot_id_state
-            )
-        
-        # --- Tabs 3 & 4: Agentic Pipeline ---
-        # build_and_wire_tabs will create TabItems internally
-        agentic_pipeline_output_components = agentic_module.build_and_wire_tabs(
-            orchestration_raw_results_st, 
-            key_results_for_selection_st, 
-            selected_key_result_ids_st
-        )
+            analytics_components = setup_analytics_tab() # This returns a dict of all components in the tab
 
+        # Agentic tabs are conditional
+        agentic_report_components = {}
+        agentic_okrs_components = {}
 
-    # --- Event Chaining & Orchestration ---
+        with gr.TabItem("3️⃣ Agentic Analysis Report", id="tab_agentic_report", visible=APP_AGENTIC_MODULES_LOADED):
+            agentic_report_components = setup_agentic_report_tab(APP_AGENTIC_MODULES_LOADED)
+        
+        with gr.TabItem("4️⃣ Agentic OKRs & Tasks", id="tab_agentic_okrs", visible=APP_AGENTIC_MODULES_LOADED):
+            agentic_okrs_components = setup_agentic_okrs_tab(APP_AGENTIC_MODULES_LOADED)
 
-    # Initial Load Sequence (Simplified: direct calls, complex logic in handlers)
-    def initial_load_sequence_wrapper(url_token, org_urn_val, current_state):
-        # This function is primarily for the first tab's initial state.
-        status_msg, new_state, btn_update = process_and_store_bubble_token(url_token, org_urn_val, current_state)
-        dashboard_content = display_main_dashboard(new_state) # From ui_generators
-        return status_msg, new_state, btn_update, dashboard_content
+    # --- Initialize Handlers ---
+    dashboard_sync_handler = DashboardSyncHandlers(
+        dashboard_components, token_state, url_user_token_display, org_urn_display, status_box
+    )
+    
+    analytics_handler = AnalyticsHandlers(
+        analytics_components, token_state, chat_histories_st, current_chat_plot_id_st, 
+        plot_data_for_chatbot_st, active_panel_action_state, explored_plot_id_state
+    )
+    
+    agentic_handler = None
+    if APP_AGENTIC_MODULES_LOADED:
+        agentic_handler = AgenticHandlers(
+            agentic_report_components, agentic_okrs_components, token_state,
+            orchestration_raw_results_st, key_results_for_selection_st, selected_key_result_ids_st
+        )
 
-    # Outputs for the agentic pipeline handler
-    # Order: report_display, key_results_cbg, okr_detail_display, 
-    #        orchestration_raw_results_st, selected_key_result_ids_st, key_results_for_selection_st, 
-    #        agentic_pipeline_status_md
-    agentic_pipeline_full_outputs_list = agentic_pipeline_output_components[:3] + \
-                                         [orchestration_raw_results_st, selected_key_result_ids_st, key_results_for_selection_st] + \
-                                         [agentic_pipeline_output_components[3]]
+    # --- Setup Event Handlers from Handler Classes ---
+    # Dashboard/Sync handlers are mostly involved in chained events below
+    analytics_handler.setup_event_handlers() # Sets up internal events for analytics tab
+    
+    if APP_AGENTIC_MODULES_LOADED and agentic_handler:
+        agentic_handler.setup_event_handlers() # Sets up internal events for agentic tabs (e.g., KR selection)
 
+    # --- Chained Event Logic (Initial Load & Sync) ---
+    
+    # Outputs for the agentic pipeline run
+    # Ensure these components exist even if the tab is not visible, or handle None gracefully.
+    agentic_pipeline_outputs_list = [
+        agentic_report_components.get("agentic_report_display_md", gr.update()),
+        agentic_okrs_components.get("key_results_cbg", gr.update()),
+        agentic_okrs_components.get("okr_detail_display_md", gr.update()),
+        orchestration_raw_results_st,
+        selected_key_result_ids_st, # This state is primarily driven by CBG, but pipeline might reset it
+        key_results_for_selection_st,
+        agentic_report_components.get("agentic_pipeline_status_md", gr.update())
+    ]
+    
+    # Initial Load Sequence:
+    # 1. Get URL token (app.load)
+    # 2. Process token, update dashboard (initial_load_sequence from dashboard_sync_handler)
+    # 3. Refresh analytics graphs (analytics_handler.refresh_analytics_graphs_ui)
+    # 4. Run agentic pipeline (agentic_handler.run_agentic_pipeline_autonomously_on_update)
 
-    initial_load_event = org_urn_display.change(
-        fn=initial_load_sequence_wrapper,
+    initial_load_event = org_urn_display.change( # Triggers after app.load populates org_urn_display
+        fn=dashboard_sync_handler.initial_load_sequence,
         inputs=[url_user_token_display, org_urn_display, token_state],
-        outputs=[status_box, token_state, sync_data_btn, dashboard_display_html],
-        show_progress="full"
+        outputs=[
+            status_box, 
+            token_state, 
+            dashboard_sync_components['sync_data_btn'], 
+            dashboard_sync_components['dashboard_display_html']
+        ],
+        show_progress="full" # For the initial data processing part
     )
-    
-    # After initial load, refresh analytics graphs
+
+    # Chain analytics refresh after initial load
     initial_load_event.then(
-        fn=analytics_tab.handle_refresh_analytics_graphs,
-        inputs=[token_state, date_filter_selector_analytics, custom_start_date_picker_analytics, custom_end_date_picker_analytics, chat_histories_st],
-        outputs=analytics_refresh_outputs_plus_states, # Use the list from analytics_tab
-        show_progress="full"
-    ).then( # Then run agentic pipeline
-        fn=agentic_module.handle_run_agentic_pipeline,
-        inputs=[token_state, orchestration_raw_results_st, key_results_for_selection_st, selected_key_result_ids_st], # Pass states
-        outputs=agentic_pipeline_full_outputs_list,
-        show_progress="minimal"
+        fn=analytics_handler.refresh_analytics_graphs_ui,
+        inputs=[
+            token_state, 
+            analytics_components['date_filter_selector'], 
+            analytics_components['custom_start_date_picker'], 
+            analytics_components['custom_end_date_picker']
+            # chat_histories_st is accessed via self.chat_histories_st in the handler
+        ],
+        outputs=analytics_handler._get_graph_refresh_outputs_list(), # Get the list of output components
+        show_progress="full" # For graph generation
     )
+    
+    # Chain agentic pipeline run after initial analytics refresh (if modules loaded)
+    if APP_AGENTIC_MODULES_LOADED and agentic_handler:
+        initial_load_event.then( # Chaining from initial_load_event ensures it uses the updated token_state
+            fn=agentic_handler.run_agentic_pipeline_autonomously_on_update,
+            inputs=[token_state], # Depends on the updated token_state
+            outputs=agentic_pipeline_outputs_list,
+            show_progress="minimal" # For agentic pipeline
+        )
 
-    # Sync Data Event Chain
-    sync_event_part1 = sync_data_btn.click(
-        fn=sync_all_linkedin_data_orchestrator,
+    # Sync Data Sequence:
+    # 1. sync_all_linkedin_data_orchestrator
+    # 2. process_and_store_bubble_token (to update state based on sync results)
+    # 3. display_main_dashboard
+    # 4. refresh_analytics_graphs_ui
+    # 5. run_agentic_pipeline_autonomously_on_update
+
+    sync_event_part1 = dashboard_sync_components['sync_data_btn'].click(
+        fn=sync_all_linkedin_data_orchestrator, # From services.sync_logic
         inputs=[token_state],
-        outputs=[sync_status_html_output, token_state], # token_state is updated here
-        show_progress="full"
+        outputs=[dashboard_sync_components['sync_status_html_output'], token_state],
+        show_progress="full" # For the main sync operation
     )
     
-    # After sync, re-process token and update dashboard display (Tab 1)
     sync_event_part2 = sync_event_part1.then(
-        fn=process_and_store_bubble_token, # This updates token_state again
-        inputs=[url_user_token_display, org_urn_display, token_state], # Pass the updated token_state
-        outputs=[status_box, token_state, sync_data_btn], # token_state updated again
-        show_progress=False 
-    )
-    
-    # After token processing, re-run agentic pipeline with potentially new data
-    sync_event_part2.then(
-        fn=agentic_module.handle_run_agentic_pipeline,
-        inputs=[token_state, orchestration_raw_results_st, key_results_for_selection_st, selected_key_result_ids_st], # Pass the latest token_state
-        outputs=agentic_pipeline_full_outputs_list,
-        show_progress="minimal"
+        fn=process_and_store_bubble_token, # From services.state_manager
+        inputs=[url_user_token_display, org_urn_display, token_state], # Uses the updated token_state from part1
+        outputs=[status_box, token_state, dashboard_sync_components['sync_data_btn']],
+        show_progress=False # Quick state update
     )
     
-    # Then, update the main dashboard display on Tab 1
-    sync_event_part3 = sync_event_part2.then(
-        fn=display_main_dashboard,
-        inputs=[token_state], # Use the latest token_state
-        outputs=[dashboard_display_html],
-        show_progress=False
+    # Chain agentic pipeline run after sync and token processing (if modules loaded)
+    if APP_AGENTIC_MODULES_LOADED and agentic_handler:
+        sync_event_part2.then(
+            fn=agentic_handler.run_agentic_pipeline_autonomously_on_update,
+            inputs=[token_state], # Uses the token_state updated by process_and_store_bubble_token
+            outputs=agentic_pipeline_outputs_list,
+            show_progress="minimal"
+        )
+        
+    sync_event_part3 = sync_event_part2.then( # Continues from token processing
+        fn=display_main_dashboard, # From ui.ui_generators
+        inputs=[token_state], # Uses the updated token_state
+        outputs=[dashboard_sync_components['dashboard_display_html']],
+        show_progress=False # Quick UI update
     )
     
-    # Finally, refresh analytics graphs on Tab 2
-    sync_event_graphs_after_sync = sync_event_part3.then(
-        fn=analytics_tab.handle_refresh_analytics_graphs,
-        inputs=[token_state, date_filter_selector_analytics, custom_start_date_picker_analytics, custom_end_date_picker_analytics, chat_histories_st],
-        outputs=analytics_refresh_outputs_plus_states, # Use the list from analytics_tab
-        show_progress="full"
+    # Chain analytics refresh after dashboard update post-sync
+    sync_event_part3.then(
+        fn=analytics_handler.refresh_analytics_graphs_ui,
+        inputs=[
+            token_state, 
+            analytics_components['date_filter_selector'], 
+            analytics_components['custom_start_date_picker'], 
+            analytics_components['custom_end_date_picker']
+        ],
+        outputs=analytics_handler._get_graph_refresh_outputs_list(),
+        show_progress="full" # For graph generation after sync
     )
 
-# --- App Launch ---
+
+# --- Launch ---
 if __name__ == "__main__":
-    if not os.environ.get(LINKEDIN_CLIENT_ID_ENV_VAR): logging.warning(f"ATTENZIONE: '{LINKEDIN_CLIENT_ID_ENV_VAR}' non impostata.")
+    # Environment variable checks (optional but good practice)
+    if not os.environ.get(LINKEDIN_CLIENT_ID_ENV_VAR): 
+        logging.warning(f"ATTENZIONE: '{LINKEDIN_CLIENT_ID_ENV_VAR}' non impostata.")
     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: Variabili Bubble non impostate.")
     
-    # AGENTIC_MODULES_LOADED is now checked within agentic_module.py, log from there if needed.
-    # We can add a check here based on the import success if desired for app startup.
-    if not agentic_module.AGENTIC_MODULES_LOADED: # Check the flag from the module
-         logging.warning("CRITICAL: Agentic pipeline modules failed to load. Tabs 3 and 4 will be non-functional.")
-    if not os.environ.get("GEMINI_API_KEY") and agentic_module.AGENTIC_MODULES_LOADED:
+    if not APP_AGENTIC_MODULES_LOADED: 
+        logging.warning("CRITICAL: Agentic pipeline modules failed to load. Agentic tabs (3 and 4) will be non-functional or hidden.")
+    
+    if not os.environ.get("GEMINI_API_KEY") and APP_AGENTIC_MODULES_LOADED: 
         logging.warning("ATTENZIONE: 'GEMINI_API_KEY' non impostata. La pipeline AI per le tab 3 e 4 potrebbe non funzionare.")
     
-    try:
+    try: 
         logging.info(f"Matplotlib: {matplotlib.__version__}, Backend: {matplotlib.get_backend()}")
-    except ImportError:
+    except ImportError: 
         logging.warning("Matplotlib non trovato.")
         
     app.launch(server_name="0.0.0.0", server_port=7860, debug=True)