Update app.py

app.py

@@ -1,6 +1,4 @@
 # app.py
-# (Showing relevant parts that need modification)
-
 import gradio as gr
 import pandas as pd
 import os
@@ -12,7 +10,7 @@ import time # For profiling if needed
 from datetime import datetime, timedelta # Added timedelta
 import numpy as np
 from collections import OrderedDict # To maintain section order
-import asyncio # For async operations with the new agent
+import asyncio # For async operations
 
 # --- Module Imports ---
 from gradio_utils import get_url_user_token
@@ -38,37 +36,13 @@ from chatbot_prompts import get_initial_insight_prompt_and_suggestions # MODIFIE
 from chatbot_handler import generate_llm_response
 # --- END EXISTING CHATBOT MODULE IMPORTS ---
 
-# --- NEW EMPLOYER BRANDING AGENT MODULE IMPORTS ---
-try:
-    from eb_agent_module import (
-        EmployerBrandingAgent, 
-        GENERATION_CONFIG_PARAMS as EB_AGENT_GEN_CONFIG, # Rename to avoid conflict
-        LLM_MODEL_NAME as EB_AGENT_LLM_MODEL,           # Rename
-        GEMINI_EMBEDDING_MODEL_NAME as EB_AGENT_EMBEDDING_MODEL, # Rename        
-        DEFAULT_SAFETY_SETTINGS as EB_AGENT_SAFETY_SETTINGS, # Import safety settings
-        get_all_schemas_representation
-    )
-    EB_AGENT_AVAILABLE = True
-    logging.info("Successfully imported EmployerBrandingAgent module.")
-except ImportError as e:
-    logging.error(f"Failed to import EmployerBrandingAgent module: {e}", exc_info=True)
-    EB_AGENT_AVAILABLE = False
-    # Define dummy classes/variables if import fails, so app can still run
-    class EmployerBrandingAgent:
-        def __init__(self, *args, **kwargs): logging.error("EB Agent Dummy Class Initialized")
-        async def process_query(self, query, **kwargs): return "# Error: Employer Branding Agent module not loaded."
-        def update_dataframes(self, dfs): pass
-        def clear_chat_history(self): pass
-    EB_AGENT_GEN_CONFIG, EB_AGENT_LLM_MODEL, EB_AGENT_EMBEDDING_MODEL, EB_AGENT_SAFETY_SETTINGS = {}, None, None, pd.DataFrame(), {}
-
-
 # Configure logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(module)s - %(message)s')
 
 
 # --- Gradio UI Blocks ---
 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:
     token_state = gr.State(value={
         "token": None, "client_id": None, "org_urn": None,
         "bubble_posts_df": pd.DataFrame(), "bubble_post_stats_df": pd.DataFrame(),
@@ -84,11 +58,6 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
     current_chat_plot_id_st = gr.State(None)
     plot_data_for_chatbot_st = gr.State({})
 
-    # --- NEW: States for Employer Branding Agent Tab ---
-    eb_agent_chat_history_st = gr.State([]) 
-    # The agent instance itself will be created on-the-fly or managed if complex state is needed.
-    # For now, we'll re-initialize it with fresh data in the handler.
-
     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...")
@@ -337,8 +306,8 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                     new_explored_plot_id_to_set 
                 ]
 
-                final_updates.extend(generated_panel_vis_updates)   
-                final_updates.extend(generated_bomb_btn_updates)    
+                final_updates.extend(generated_panel_vis_updates)  
+                final_updates.extend(generated_bomb_btn_updates)   
                 final_updates.extend(generated_formula_btn_updates) 
                 final_updates.extend(generated_explore_btn_updates) 
                 final_updates.extend(section_title_vis_updates)     
@@ -610,214 +579,6 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                 show_progress="full"
             )
         
-        # --- NEW: Tab 5 for Employer Branding Agent ---
-        with gr.TabItem("5️⃣ Agente AI Employer Branding", id="tab_eb_agent"):
-            gr.Markdown("## 🤖 Interagisci con l'Agente AI per l'Employer Branding")
-            
-            if not EB_AGENT_AVAILABLE:
-                gr.Markdown("<p style='color:red;font-weight:bold;'>Attenzione: Il modulo dell'Agente AI per l'Employer Branding non è stato caricato correttamente. Controllare i log e l'installazione della libreria `google-generativeai` e la variabile d'ambiente `GEMINI_API_KEY`.</p>")
-            elif not os.getenv('GEMINI_API_KEY'):
-                 gr.Markdown("<p style='color:orange;font-weight:bold;'>Attenzione: La variabile d'ambiente `GEMINI_API_KEY` non è impostata. Le funzionalità dell'Agente AI saranno limitate o non funzioneranno.</p>")
-
-
-            gr.Markdown(
-                "Fai domande sui tuoi dati LinkedIn (statistiche follower, post e menzioni) per ottenere insights e codice Pandas per analizzarli. "
-                "L'agente utilizza i dati attualmente disponibili nello stato dell'applicazione."
-            )
-            with gr.Row():
-                with gr.Column(scale=2):
-                    eb_agent_chatbot_ui = gr.Chatbot(
-                        label="Chat con Agente AI EB",
-                        value=[[None, "Ciao! Sono il tuo Agente AI per l'Employer Branding. Come posso aiutarti ad analizzare i tuoi dati LinkedIn oggi? Chiedimi di generare codice Pandas o di fornire insights."]] if EB_AGENT_AVAILABLE else [[None, "Agente AI non disponibile."]],
-                        bubble_full_width=False,
-                        height=500,
-                        placeholder="L'Agente AI è pronto. Chiedi pure..."
-                    )
-                    eb_agent_chat_input_ui = gr.Textbox(
-                        label="La tua domanda:",
-                        placeholder="Es: 'Mostrami le aziende dei miei follower nel settore tecnologico' o 'Qual è il sentiment medio delle mie menzioni?'",
-                        lines=3,
-                        interactive=EB_AGENT_AVAILABLE # Disable if agent not available
-                    )
-                    with gr.Row():
-                        eb_agent_submit_btn = gr.Button("💬 Invia Messaggio", variant="primary", interactive=EB_AGENT_AVAILABLE)
-                        eb_agent_clear_btn = gr.Button("🗑️ Cancella Chat", variant="stop", interactive=EB_AGENT_AVAILABLE)
-                with gr.Column(scale=1):
-                    gr.Markdown("#### Schemi Dati Disponibili per l'Agente:")
-                    eb_agent_schema_display_md = gr.Markdown("Gli schemi dei dati (follower, post, menzioni) verranno mostrati qui quando l'agente viene inizializzato con una query.")
-                    eb_agent_status_md = gr.Markdown("Stato Agente: In attesa di input...")
-            
-            # --- NEW: Handler for Employer Branding Agent Chat ---
-            eb_agent_instance_dict = {"agent": None} # To store agent instance across calls if needed, or re-init
-            
-            async def handle_eb_agent_chat(user_message: str, chat_history_list: list, current_token_state: dict):
-                current_chat_history = list(chat_history_list) if chat_history_list else []
-    
-                if not EB_AGENT_AVAILABLE or not os.getenv('GEMINI_API_KEY'):
-                    no_key_msg = "L'Agente AI non è disponibile. Assicurati che GEMINI_API_KEY sia configurata e che l'agente sia caricato."
-                    current_chat_history.append([user_message, no_key_msg])
-                    # Ensure all outputs are updated
-                    yield current_chat_history, current_chat_history, gr.update(value=""), gr.update(value=no_key_msg), gr.update(value="Nessuno schema disponibile.")
-                    return
-    
-                if not user_message.strip():
-                    # Ensure all outputs are updated even for empty message
-                    yield current_chat_history, current_chat_history, gr.update(value=""), gr.update(value="Stato Agente: Per favore, inserisci una domanda."), gr.update()
-                    return
-                
-                status_update_msg = "Stato Agente: Elaborazione della tua richiesta..."
-                pending_history = current_chat_history + [[user_message, None]]
-                # Yield intermediate state to show user message immediately
-                yield pending_history, pending_history, gr.update(value=""), gr.update(value=status_update_msg), gr.update()
-    
-                # Prepare DataFrames for the agent
-                df_follower_stats = current_token_state.get("bubble_follower_stats_df", pd.DataFrame())
-                df_posts = current_token_state.get("bubble_posts_df", pd.DataFrame())  
-                df_post_stats = current_token_state.get("bubble_post_stats_df", pd.DataFrame())  
-                df_mentions = current_token_state.get("bubble_mentions_df", pd.DataFrame())
-                
-                dataframes_for_agent = {
-                    "follower_stats": df_follower_stats.copy() if not df_follower_stats.empty else pd.DataFrame(columns=['no_data_follower_stats']),
-                    "posts": df_posts.copy() if not df_posts.empty else pd.DataFrame(columns=['no_data_posts']),
-                    "post_stats": df_post_stats.copy() if not df_post_stats.empty else pd.DataFrame(columns=['no_data_post_stats']),
-                    "mentions": df_mentions.copy() if not df_mentions.empty else pd.DataFrame(columns=['no_data_mentions'])
-                }
-                
-                schemas_text_for_display = "Schemi DataFrames inviati all'Agente:\n\n"
-                schemas_text_for_display += get_all_schemas_representation(dataframes_for_agent)
-                max_schema_display_len = 1500
-                if len(schemas_text_for_display) > max_schema_display_len:
-                    schemas_text_for_display = schemas_text_for_display[:max_schema_display_len] + "\n...(schemi troncati per la visualizzazione)"
-                
-                # Update schema display before agent call
-                yield pending_history, pending_history, gr.update(value=""), gr.update(value=status_update_msg), gr.update(value=schemas_text_for_display)
-    
-                current_agent = EmployerBrandingAgent(
-                    llm_model_name="gemini-2.5-flash-preview-05-20", # Replace with your actual EB_AGENT_LLM_MODEL
-                    generation_config_dict={}, # Replace with your actual EB_AGENT_GEN_CONFIG
-                    safety_settings_list=[], # Replace with your actual EB_AGENT_SAFETY_SETTINGS
-                    all_dataframes=dataframes_for_agent,
-                    embedding_model_name="gemini-embedding-exp-03-07" # Replace with your actual EB_AGENT_EMBEDDING_MODEL
-                )
-                
-                agent_internal_history = []
-                for user_q, ai_r_obj in current_chat_history: # Iterate over the current history being built
-                    if user_q: agent_internal_history.append({"role": "user", "content": user_q})
-                    # ai_r_obj could be string, tuple (text, image_url), or None
-                    if ai_r_obj:
-                        if isinstance(ai_r_obj, tuple):
-                            # If it's a (text, image_url) tuple, take the text part for agent's history
-                            # Or combine them if your agent can handle it. For simplicity, just text.
-                            text_for_agent_history = ai_r_obj[0] if ai_r_obj[0] else "Visual media displayed."
-                            agent_internal_history.append({"role": "model", "content": text_for_agent_history})
-                        elif isinstance(ai_r_obj, str):
-                            agent_internal_history.append({"role": "model", "content": ai_r_obj})
-            
-                # ADD THE CURRENT USER MESSAGE TO THE AGENT'S HISTORY
-                agent_internal_history.append({"role": "user", "content": user_message})
-                current_agent.chat_history = agent_internal_history
-                
-                try:
-                    init_success = await current_agent.initialize()
-                    if not init_success:
-                        error_msg = "Errore: Impossibile inizializzare l'agente AI."
-                        # Use pending_history which already has the user message
-                        updated_history = pending_history[:-1] + [[user_message, error_msg]] # Replace None with error
-                        yield updated_history, updated_history, gr.update(value=""), gr.update(value="Stato Agente: Errore di inizializzazione"), gr.update(value=schemas_text_for_display)
-                        return
-                    
-                    logging.info(f"Sending to EB Agent. User: '{user_message}'. DF Keys: {list(dataframes_for_agent.keys())}")
-                    ai_response_dict = await current_agent.process_query(user_query=user_message)  
-                    
-                    bot_message_for_display = "Error: Agent returned an unexpected response." # Default
-                    agent_text_response = None
-                    agent_image_path = None
-                    bot_response_list_for_history = []
-    
-                    if isinstance(ai_response_dict, dict):
-                        agent_text_response = ai_response_dict.get("text")
-                        agent_image_path = ai_response_dict.get("image_path")
-    
-                        logging.info(f"Agent response: text='{str(agent_text_response)[:100]}...', image_path='{agent_image_path}'")
-    
-                        if agent_image_path and os.path.exists(agent_image_path):
-                            text_for_display = str(agent_text_response) if agent_text_response is not None else ""
-                        
-                            if text_for_display.strip(): # If there's actual text, add it as the first bot message
-                                bot_response_list_for_history.append(text_for_display)
-                                logging.info(f"Adding text message to chat: '{text_for_display[:100]}...'")
-                            
-                            # Add the image as a second bot message (or first if no text)
-                            # Using a simple caption for the image tuple
-                            bot_response_list_for_history.append(( "📊 Generated Chart", agent_image_path))
-                            logging.info(f"Adding image message to chat: {agent_image_path}")
-                            status_update_msg = "Stato Agente: Risposta con grafico ricevuta."
-    
-                        elif agent_text_response is not None: 
-                            bot_response_list_for_history.append(str(agent_text_response))
-                            if agent_image_path: 
-                                logging.warning(f"Agent provided image_path '{agent_image_path}' but it does not exist or was not used.")
-                            status_update_msg = "Stato Agente: Risposta testuale ricevuta."
-                        else:
-                            bot_response_list_for_history.append("L'agente ha risposto, ma il contenuto non è visualizzabile.")
-                            logging.warning(f"AI response dict issue. Text: {agent_text_response}, Image Path: {agent_image_path}")
-                            status_update_msg = "Stato Agente: Risposta con problemi."
-                    
-                    elif isinstance(ai_response_dict, str): 
-                        bot_response_list_for_history.append(ai_response_dict)
-                        logging.warning(f"AI response was a plain string: {ai_response_dict}")
-                        status_update_msg = "Stato Agente: Risposta testuale ricevuta."
-                    else: 
-                        bot_response_list_for_history.append(f"Error: Agent returned an unexpected data type: {type(ai_response_dict)}.")
-                        logging.error(f"Unexpected AI response type: {type(ai_response_dict)}, content: {ai_response_dict}")
-                        status_update_msg = "Stato Agente: Errore nella risposta."
-    
-                    # Construct the final history
-                    # pending_history already has [user_message, None]
-                    # We replace the None with the first bot response, then append any subsequent bot responses
-                    final_updated_history = pending_history[:-1] # Remove the [user_message, None]
-                    final_updated_history.append([user_message, bot_response_list_for_history[0] if bot_response_list_for_history else "No response content."])
-                    if len(bot_response_list_for_history) > 1:
-                        for bot_msg_item in bot_response_list_for_history[1:]:
-                            final_updated_history.append([None, bot_msg_item]) # Subsequent messages from bot have None for user part
-                    
-                    yield final_updated_history, final_updated_history, gr.update(value=""), gr.update(value=status_update_msg), gr.update(value=schemas_text_for_display)
-                    return
-                
-                except Exception as e:
-                    logging.error(f"Error during EB Agent processing: {e}", exc_info=True)
-                    error_msg_for_chat = f"# Errore dell'Agente AI:\n{type(e).__name__}: {str(e)}"
-                    updated_history = pending_history[:-1] + [[user_message, error_msg_for_chat]]
-                    status_update_msg = f"Stato Agente: Errore - {type(e).__name__}"
-                    yield updated_history, updated_history, gr.update(value=""), gr.update(value=status_update_msg), gr.update(value=schemas_text_for_display)
-                    return
-
-            def clear_eb_agent_chat_history():
-                initial_msg = "Ciao! Sono il tuo Agente AI per l'Employer Branding. Come posso aiutarti?" if EB_AGENT_AVAILABLE else "Agente AI non disponibile."
-                # Ensure all outputs are updated
-                return [[None, initial_msg]], [[None, initial_msg]], "Stato Agente: Chat resettata.", gr.update(value="Gli schemi dei dati verranno mostrati qui...")
-
-
-            # Connect UI to Handler for EB Agent
-            eb_agent_submit_btn.click(
-                fn=handle_eb_agent_chat,
-                inputs=[eb_agent_chat_input_ui, eb_agent_chat_history_st, token_state],
-                outputs=[eb_agent_chatbot_ui, eb_agent_chat_history_st, eb_agent_chat_input_ui, eb_agent_status_md, eb_agent_schema_display_md],
-                api_name="eb_agent_chat_submit"
-            )
-            eb_agent_chat_input_ui.submit(
-                fn=handle_eb_agent_chat,
-                inputs=[eb_agent_chat_input_ui, eb_agent_chat_history_st, token_state],
-                outputs=[eb_agent_chatbot_ui, eb_agent_chat_history_st, eb_agent_chat_input_ui, eb_agent_status_md, eb_agent_schema_display_md],
-                api_name="eb_agent_chat_enter"
-            )
-            eb_agent_clear_btn.click(
-                fn=clear_eb_agent_chat_history,
-                inputs=[],
-                outputs=[eb_agent_chatbot_ui, eb_agent_chat_history_st, eb_agent_status_md],
-                api_name="eb_agent_clear_chat"
-            )
-
 
     # --- Sync Events (at the end of the app's 'with gr.Blocks()' context) ---
     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")
@@ -836,13 +597,7 @@ if __name__ == "__main__":
     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.")
     
-    if not EB_AGENT_AVAILABLE:
-        logging.error("L'Agente AI per l'Employer Branding non è disponibile a causa di errori di importazione.")
-    elif not os.getenv('GEMINI_API_KEY'):
-        logging.warning("ATTENZIONE: GEMINI_API_KEY non è impostata. L'Agente AI per l'Employer Branding potrebbe non funzionare.")
-
     try: logging.info(f"Matplotlib: {matplotlib.__version__}, Backend: {matplotlib.get_backend()}")
     except ImportError: logging.warning("Matplotlib non trovato.")
     
     app.launch(server_name="0.0.0.0", server_port=7860, debug=True)
-