Update ui/callbacks.py

ui/callbacks.py

@@ -2,35 +2,50 @@
 
 # -*- coding: utf-8 -*-
 #
-# PROJECT:      CognitiveEDA v5.0 - The QuantumLeap Intelligence Platform
+# PROJECT:      CognitiveEDA v5.2 - The QuantumLeap Intelligence Platform
 #
-# DESCRIPTION:  This module now contains only the CORE LOGIC for the Gradio
-#               event handlers. It exports these functions to be attached to
-#               listeners within the main application context.
+# DESCRIPTION:  The "Controller" logic of the application. This module contains
+#               the Python functions that execute when Gradio events are triggered.
+#               It is designed to be completely decoupled from the UI definition
+#               and event attachment process.
 
 import gradio as gr
 import pandas as pd
 import logging
 from threading import Thread
 
+import plotly.graph_objects as go
+import plotly.express as px
+
 from core.analyzer import DataAnalyzer
 from core.llm import GeminiNarrativeGenerator
 from core.config import settings
 from core.exceptions import DataProcessingError
 from modules.clustering import perform_clustering
-# ... other module imports
+from modules.text import generate_word_cloud
+from modules.timeseries import analyze_time_series
+
+
+# --- Primary Analysis Chain ---
 
-# --- Main Analysis Logic ---
-def run_full_analysis(file_obj, progress=gr.Progress(track_tqdm=True)):
+def run_initial_analysis(file_obj, progress=gr.Progress(track_tqdm=True)):
     """
-    The primary orchestration function. This is the logic that will be called
-    by the 'analyze_button.click' event.
+    Phase 1 of the analysis: Fast, synchronous tasks.
+    Validates inputs, loads data, and creates the core DataAnalyzer object.
+
+    Args:
+        file_obj: The uploaded file object from Gradio.
+        progress: The Gradio progress tracker.
+
+    Returns:
+        The instantiated DataAnalyzer object, which will update the gr.State.
+        Returns None if any validation or processing fails.
     """
-    # 1. Input Validation (File)
+    # 1. Input Validation
     if file_obj is None:
         raise gr.Error("No file uploaded. Please upload a CSV or Excel file.")
 
-    # 2. Runtime Configuration Validation (API Key)
+    # 2. Runtime Configuration Validation
     progress(0, desc="Validating configuration...")
     if not settings.GOOGLE_API_KEY:
         logging.error("Analysis attempted without GOOGLE_API_KEY set.")
@@ -40,37 +55,47 @@ def run_full_analysis(file_obj, progress=gr.Progress(track_tqdm=True)):
         )
 
     try:
-        # 3. Data Loading & Core Analysis
-        progress(0.1, desc="Loading and parsing data...")
+        # 3. Data Loading
+        progress(0.2, desc="Loading and parsing data file...")
         df = pd.read_csv(file_obj.name) if file_obj.name.endswith('.csv') else pd.read_excel(file_obj.name)
         if len(df) > settings.MAX_UI_ROWS:
             df = df.sample(n=settings.MAX_UI_ROWS, random_state=42)
+            logging.info(f"DataFrame sampled down to {settings.MAX_UI_ROWS} rows.")
 
-        progress(0.3, desc="Instantiating analysis engine...")
+        # 4. Core Analyzer Instantiation
+        progress(0.7, desc="Instantiating analysis engine...")
         analyzer = DataAnalyzer(df)
-        return analyzer # We will return the analyzer and handle the rest in a subsequent step
+        progress(1.0, desc="Initial analysis complete.")
+        return analyzer
 
     except DataProcessingError as e:
         logging.error(f"User-facing data processing error: {e}", exc_info=True)
         raise gr.Error(str(e))
     except Exception as e:
-        logging.error(f"A critical unhandled error occurred: {e}", exc_info=True)
+        logging.error(f"A critical unhandled error occurred during initial analysis: {e}", exc_info=True)
         raise gr.Error(f"Analysis Failed! An unexpected error occurred: {str(e)}")
 
 
 def generate_reports_and_visuals(analyzer, progress=gr.Progress(track_tqdm=True)):
     """
-    A generator function that yields UI updates. Triggered after the analyzer is created.
+    Phase 2 of the analysis: Slower, multi-stage tasks.
+    This generator function yields UI updates as they become available.
+
+    Args:
+        analyzer: The DataAnalyzer object from the gr.State.
+        progress: The Gradio progress tracker.
+
+    Yields:
+        A dictionary of Gradio updates to populate the dashboard.
     """
-    if not analyzer:
-        # This prevents errors if the initial analysis failed.
-        # Create an empty dictionary that matches the structure of `updates`
-        # so Gradio has something to unpack.
-        return { "state_analyzer": None }
-
-    # 1. Start AI thread
-    progress(0.1, desc="Spawning AI report thread...")
-    ai_report_queue = [""]
+    # Guard clause: Do nothing if the initial analysis failed.
+    if not isinstance(analyzer, DataAnalyzer):
+        logging.warning("generate_reports_and_visuals called without a valid analyzer. Aborting.")
+        return {}
+
+    # 1. Start AI narrative generation in a background thread
+    progress(0, desc="Spawning AI report thread...")
+    ai_report_queue = [""]  # Use a mutable list to pass string by reference
     def generate_ai_report_threaded(analyzer_instance):
         narrative_generator = GeminiNarrativeGenerator(api_key=settings.GOOGLE_API_KEY)
         ai_report_queue[0] = narrative_generator.generate_narrative(analyzer_instance)
@@ -78,16 +103,16 @@ def generate_reports_and_visuals(analyzer, progress=gr.Progress(track_tqdm=True)
     thread = Thread(target=generate_ai_report_threaded, args=(analyzer,))
     thread.start()
 
-    # 2. Generate standard reports
-    progress(0.4, desc="Generating data profiles...")
+    # 2. Generate standard reports and visuals (this is fast)
+    progress(0.4, desc="Generating data profiles and visuals...")
     meta = analyzer.metadata
     missing_df, num_df, cat_df = analyzer.get_profiling_reports()
     fig_types, fig_missing, fig_corr = analyzer.get_overview_visuals()
 
-    # 3. Yield initial updates
+    # 3. Yield the first set of updates to populate the main dashboard immediately
     progress(0.8, desc="Building initial dashboard...")
     initial_updates = {
-        "ai_report_output": gr.update(value="⏳ Generating AI report... Main dashboard is ready."),
+        "ai_report_output": gr.update(value="⏳ Generating AI-powered report in the background... The main dashboard is ready now."),
         "profile_missing_df": gr.update(value=missing_df),
         "profile_numeric_df": gr.update(value=num_df),
         "profile_categorical_df": gr.update(value=cat_df),
@@ -104,15 +129,61 @@ def generate_reports_and_visuals(analyzer, progress=gr.Progress(track_tqdm=True)
     }
     yield initial_updates
 
-    # 4. Wait for thread and yield final AI report
+    # 4. Wait for the AI thread to complete
     thread.join()
     progress(1.0, desc="AI Report complete!")
+
+    # 5. Yield the final update, now including the AI-generated report
     final_updates = initial_updates.copy()
     final_updates["ai_report_output"] = ai_report_queue[0]
     yield final_updates
 
-# --- Other Interactive Callback Logic ---
+
+# --- Interactive Explorer Callbacks ---
+
+def create_histogram(analyzer, col):
+    """Generates a histogram for a selected numeric column."""
+    if not isinstance(analyzer, DataAnalyzer) or not col:
+        return go.Figure().update_layout(title="Select a column to generate a histogram")
+    return px.histogram(analyzer.df, x=col, title=f"<b>Distribution of {col}</b>", marginal="box", template="plotly_white")
+
+def create_scatterplot(analyzer, x_col, y_col, color_col):
+    """Generates a scatter plot for selected X, Y, and optional color columns."""
+    if not isinstance(analyzer, DataAnalyzer) or not x_col or not y_col:
+        return go.Figure().update_layout(title="Select X and Y axes to generate a scatter plot")
+    
+    # Use a subset for performance on large datasets
+    df_sample = analyzer.df
+    if len(analyzer.df) > 10000:
+        df_sample = analyzer.df.sample(n=10000, random_state=42)
+
+    return px.scatter(
+        df_sample, x=x_col, y=y_col, color=color_col if color_col else None,
+        title=f"<b>Scatter Plot: {x_col} vs. {y_col}</b>", template="plotly_white"
+    )
+
+
+# --- Specialized Module Callbacks ---
+
 def update_clustering(analyzer, k):
-    if not analyzer: return gr.update(), gr.update(), gr.update()
+    """Callback for the clustering module."""
+    if not isinstance(analyzer, DataAnalyzer):
+        return gr.update(), gr.update(), gr.update(value="Run analysis first.")
+    
+    # Delegate the heavy lifting to the specialized module
     fig_cluster, fig_elbow, summary = perform_clustering(analyzer.df, analyzer.metadata['numeric_cols'], k)
-    return fig_cluster, fig_elbow, summary
+    return fig_cluster, fig_elbow, summary
+
+# Add other specialized callbacks for text and time-series here if needed.
+# For example, if you add the dropdowns and plots to the layout:
+#
+# def update_timeseries(analyzer, date_col, value_col):
+#     if not isinstance(analyzer, DataAnalyzer):
+#         return gr.update(), gr.update(value="Run analysis first.")
+#     fig, md = analyze_time_series(analyzer.df, date_col, value_col)
+#     return fig, md
+#
+# def update_text(analyzer, text_col):
+#     if not isinstance(analyzer, DataAnalyzer):
+#         return gr.update()
+#     return generate_word_cloud(analyzer.df, text_col)