LinkedinMonitor / app.py
GuglielmoTor's picture
Update app.py
ddc6277 verified
raw
history blame
18.4 kB
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
# --- Module Imports ---
from utils.gradio_utils import get_url_user_token
# Functions from newly created/refactored modules
from config import (
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
)
# 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,
BOMB_ICON, EXPLORE_ICON, FORMULA_ICON, ACTIVE_ICON
)
from ui.analytics_plot_generator import update_analytics_plots_figures, create_placeholder_plot
from formulas import PLOT_FORMULAS
# --- CHATBOT MODULE IMPORTS ---
from features.chatbot.chatbot_prompts import get_initial_insight_prompt_and_suggestions
from features.chatbot.chatbot_handler import generate_llm_response
# --- AGENTIC PIPELINE (DISPLAY ONLY) IMPORTS ---
try:
# This is the main function called on initial load to populate the agentic tabs
from run_agentic_pipeline import load_and_display_agentic_results
# This function is now called when a new report is selected from the dropdown
from services.report_data_handler import fetch_and_reconstruct_data_from_bubble
# UI formatting functions
from ui.insights_ui_generator import (
format_report_for_display,
extract_key_results_for_selection,
format_single_okr_for_display
)
AGENTIC_MODULES_LOADED = True
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
# Placeholder functions to prevent app from crashing if imports fail
def load_and_display_agentic_results(*args, **kwargs):
return "Modules not loaded.", gr.update(), "Modules not loaded.", "Modules not loaded.", None, [], [], "Error"
def fetch_and_reconstruct_data_from_bubble(*args, **kwargs):
return None
def format_report_for_display(report_data):
return "Agentic modules not loaded. Report display unavailable."
def extract_key_results_for_selection(okr_data):
return []
def format_single_okr_for_display(okr_data, **kwargs):
return "Agentic modules not loaded. OKR display unavailable."
# --- 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
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("CRITICAL ERROR: The API key environment variable 'GEMINI_API_KEY' was not found.")
with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
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(),
"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 analytics tab chatbot
chat_histories_st = gr.State({})
current_chat_plot_id_st = gr.State(None)
plot_data_for_chatbot_st = gr.State({})
# 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")
# 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)
# 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, dashboard_content
# 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,
current_chat_plot_id_st=current_chat_plot_id_st,
plot_data_for_chatbot_st=plot_data_for_chatbot_st,
plot_id_to_formula_map=PLOT_ID_TO_FORMULA_KEY_MAP,
plot_formulas_data=PLOT_FORMULAS,
icons=analytics_icons,
fn_build_plot_area=build_analytics_tab_plot_area,
fn_update_plot_figures=update_analytics_plots_figures,
fn_create_placeholder_plot=create_placeholder_plot,
fn_get_initial_insight=get_initial_insight_prompt_and_suggestions,
fn_generate_llm_response=generate_llm_response
)
# --- MODIFIED: Comprehensive handler for report selection and OKR display ---
def update_report_and_okr_display(selected_report_id: str, current_token_state: dict):
"""
Finds the selected report in the state, formats its text for display,
and crucially, fetches and reconstructs its associated OKRs and Tasks from Bubble.
Returns a full set of UI updates for all agentic components.
"""
# Define a default/error return tuple that matches the output components
error_return_tuple = (
gr.update(value="*Please select a report to view its details.*"),
gr.update(choices=[], value=[], interactive=False),
gr.update(value="*Please select a report to see OKRs.*"),
None,
[],
[]
)
if not selected_report_id:
return error_return_tuple
agentic_df = current_token_state.get("bubble_agentic_analysis_data")
if agentic_df is None or agentic_df.empty:
return error_return_tuple
selected_report_series_df = agentic_df[agentic_df['_id'] == selected_report_id]
if selected_report_series_df.empty:
error_return_tuple[0] = gr.update(value=f"*Error: Report with ID {selected_report_id} not found.*")
return error_return_tuple
selected_report_series = selected_report_series_df.iloc[0]
# 1. Format the main report text
report_markdown = format_report_for_display(selected_report_series)
# 2. Fetch and reconstruct the full OKR data for the selected report
reconstructed_data = fetch_and_reconstruct_data_from_bubble(selected_report_series)
# 3. Prepare UI updates for the OKR section based on the reconstructed data
if reconstructed_data:
raw_results_state = reconstructed_data
actionable_okrs_dict = reconstructed_data.get("actionable_okrs", {})
all_krs_state = extract_key_results_for_selection(actionable_okrs_dict)
if all_krs_state:
kr_choices = [(kr['kr_description'], kr['unique_kr_id']) for kr in all_krs_state]
key_results_cbg_update = gr.update(choices=kr_choices, value=[], interactive=True)
# Format all OKRs for initial display
okrs_list = actionable_okrs_dict.get("okrs", [])
output_md_parts = [
format_single_okr_for_display(okr_data, okr_main_index=okr_idx)
for okr_idx, okr_data in enumerate(okrs_list)
]
okr_details_md = "\n\n---\n\n".join(output_md_parts) if output_md_parts else "No OKRs are defined in this report."
else:
key_results_cbg_update = gr.update(choices=[], value=[], interactive=False)
okr_details_md = "No Key Results were found for this report."
all_krs_state = []
else:
# Handle case where reconstruction fails
key_results_cbg_update = gr.update(choices=[], value=[], interactive=False)
okr_details_md = "Error: Could not fetch or reconstruct OKR data for this report."
raw_results_state = None
all_krs_state = []
# 4. Return the complete set of updates for the UI
return (
report_markdown,
key_results_cbg_update,
okr_details_md,
raw_results_state,
[], # Reset selected key results on new report selection
all_krs_state
)
with gr.Tabs() as tabs:
with gr.TabItem("1️⃣ Dashboard", id="tab_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
analytics_tab_instance.create_tab_ui()
# Tab 3: Agentic Analysis Report - MODIFIED
with gr.TabItem("3️⃣ Agentic Analysis Report", id="tab_agentic_report", visible=AGENTIC_MODULES_LOADED):
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. Seleziona un report dalla libreria per visualizzarlo.")
with gr.Row():
report_selector_dd = gr.Dropdown(
label="Report Library",
choices=[],
interactive=True,
info="Select a previously generated report to view its details."
)
agentic_report_display_md = gr.Markdown("Please select a report from the library to view it.")
if not AGENTIC_MODULES_LOADED:
gr.Markdown("🔴 **Error:** Agentic pipeline display modules could not be loaded. This tab is disabled.")
# 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 (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 display modules could not be loaded. This tab is disabled.")
with gr.Row():
with gr.Column(scale=1):
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 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 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 dati di analisi caricati.")
okrs_list = actionable_okrs_dict["okrs"]
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:
if kr_unique_id in kr_id_to_indices:
okr_idx, kr_idx = kr_id_to_indices[kr_unique_id]
selected_krs_by_okr_idx[okr_idx].append(kr_idx)
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]
)
# --- MODIFIED: Event binding for the report selector dropdown ---
# This now updates all agentic components, not just the report text.
if AGENTIC_MODULES_LOADED:
# Define the list of outputs that the handler function will update
report_selection_outputs = [
agentic_report_display_md,
key_results_cbg,
okr_detail_display_md,
orchestration_raw_results_st,
selected_key_result_ids_st,
key_results_for_selection_st
]
report_selector_dd.change(
fn=update_report_and_okr_display,
inputs=[report_selector_dd, token_state],
outputs=report_selection_outputs,
show_progress="minimal"
)
# --- EVENT HANDLING (SIMPLIFIED) ---
# The output list for the initial agentic load
agentic_display_outputs = [
agentic_report_display_md,
report_selector_dd,
key_results_cbg,
okr_detail_display_md,
orchestration_raw_results_st,
selected_key_result_ids_st,
key_results_for_selection_st,
agentic_pipeline_status_md
]
# This is the main event chain that runs when the app loads
initial_load_event = org_urn_display.change(
fn=initial_data_load_sequence,
inputs=[url_user_token_display, org_urn_display, token_state],
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=[
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"
# Then, load and display the pre-computed agentic results, including reconstructed OKRs
).then(
fn=load_and_display_agentic_results,
inputs=[token_state], # Inputs simplified as the function now gets everything from state
outputs=agentic_display_outputs,
show_progress="minimal"
)
if __name__ == "__main__":
# Environment variable checks remain important
if not os.environ.get(LINKEDIN_CLIENT_ID_ENV_VAR):
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("WARNING: One or more Bubble environment variables are not set.")
if not AGENTIC_MODULES_LOADED:
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)