Update app.py

app.py

@@ -49,9 +49,9 @@ except ImportError as e:
     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"
+        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
+        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):
@@ -84,7 +84,6 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
         "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"
@@ -96,29 +95,27 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
     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
+    orchestration_raw_results_st = gr.State(None)
+    key_results_for_selection_st = gr.State([])
+    selected_key_result_ids_st = gr.State([])
+    
+    # --- NEW: Session-specific cache for reconstructed OKR data ---
+    reconstruction_cache_st = gr.State({})
+
 
     # --- 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,
@@ -135,23 +132,14 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
         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
+    # --- MODIFIED: Handler now uses the session cache ---
+    def update_report_and_okr_display(selected_report_id: str, current_token_state: dict, session_cache: dict):
         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,
-            [],
-            []
+            None, [], [], session_cache # Pass cache back unchanged
         )
-
         if not selected_report_id:
             return error_return_tuple
         
@@ -165,49 +153,33 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
             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)
+        # Use the session cache
+        reconstructed_data, updated_cache = fetch_and_reconstruct_data_from_bubble(selected_report_series, session_cache)
 
-        # 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."
+                output_md_parts = [format_single_okr_for_display(okr, okr_main_index=i) for i, okr in enumerate(okrs_list)]
+                okr_details_md = "\n\n---\n\n".join(output_md_parts) if output_md_parts else "No OKRs defined."
             else:
                 key_results_cbg_update = gr.update(choices=[], value=[], interactive=False)
-                okr_details_md = "No Key Results were found for this report."
+                okr_details_md = "No Key Results 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 = []
+            okr_details_md = "Error: Could not fetch or reconstruct OKR data."
+            raw_results_state, all_krs_state = None, []
         
-        # 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
+            report_markdown, key_results_cbg_update, okr_details_md,
+            raw_results_state, [], all_krs_state, updated_cache
         )
 
     with gr.Tabs() as tabs:
@@ -215,71 +187,52 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
             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.")
-            
+            gr.Markdown("Questo report è stato pre-generato. 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."
-                )
-            
+                report_selector_dd = gr.Dropdown(label="Report Library", choices=[], interactive=True, info="Select a report.")
             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.")
+                gr.Markdown("🔴 **Error:** Agentic modules could not be loaded.")
 
-        # 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.")
+            gr.Markdown("Basato sull'analisi AI, 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.")
+                gr.Markdown("🔴 **Error:** Agentic modules could not be loaded.")
             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}
+                    gr.Markdown("### Detailed OKRs and Tasks")
+                    okr_detail_display_md = gr.Markdown("I dettagli OKR appariranno qui.")
+
+            def update_okr_display_on_selection(selected_kr_ids: list, raw_results: dict, all_krs: list):
+                if not raw_results or not AGENTIC_MODULES_LOADED:
+                    return gr.update(value="Nessun dato di analisi caricato.")
+                actionable_okrs = raw_results.get("actionable_okrs")
+                if not actionable_okrs or not isinstance(actionable_okrs.get("okrs"), list):
+                    return gr.update(value="Nessun OKR trovato.")
+                okrs_list, kr_id_map = actionable_okrs["okrs"], {kr['unique_kr_id']: (kr['okr_index'], kr['kr_index']) for kr in all_krs}
                 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]
+                if selected_kr_ids:
+                    for kr_id in selected_kr_ids:
+                        if kr_id in kr_id_map:
+                            okr_idx, kr_idx = kr_id_map[kr_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
+                output_parts = []
+                for okr_idx, okr in enumerate(okrs_list):
+                    if not selected_kr_ids:
+                        output_parts.append(format_single_okr_for_display(okr, okr_main_index=okr_idx))
+                    elif okr_idx in selected_krs_by_okr_idx:
                         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."
+                        output_parts.append(format_single_okr_for_display(okr, accepted_kr_indices=accepted_indices, okr_main_index=okr_idx))
+                final_md = "\n\n---\n\n".join(output_parts) if output_parts else "Nessun OKR corrisponde alla selezione."
                 return gr.update(value=final_md)
 
             if AGENTIC_MODULES_LOADED:
@@ -289,39 +242,25 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                     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
+            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, reconstruction_cache_st # Pass cache state back
         ]
         report_selector_dd.change(
             fn=update_report_and_okr_display,
-            inputs=[report_selector_dd, token_state],
+            inputs=[report_selector_dd, token_state, reconstruction_cache_st], # Pass cache state in
             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
+        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, reconstruction_cache_st # Pass cache state back
     ]
 
-    # 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],
@@ -329,35 +268,27 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
         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
-        ],
+        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
+        inputs=[token_state, reconstruction_cache_st], # Pass cache state in
         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.")
+        logging.warning("CRITICAL: Agentic modules failed to load.")
     if not os.environ.get("GEMINI_API_KEY"):
-        logging.warning("WARNING: 'GEMINI_API_KEY' is not set. This may be needed for chatbot features.")
+        logging.warning("WARNING: 'GEMINI_API_KEY' is not set.")
 
     app.launch(server_name="0.0.0.0", server_port=int(os.environ.get("PORT", 7860)), debug=True)