Update app.py

app.py

@@ -1,115 +1,112 @@
-# ui/layout.py
+# app.py
 
 # -*- coding: utf-8 -*-
 #
-# PROJECT:      CognitiveEDA v5.0 - The QuantumLeap Intelligence Platform
+# PROJECT:      CognitiveEDA v5.3 - The QuantumLeap Intelligence Platform
 #
-# DESCRIPTION:  This module defines the entire Gradio UI structure. It is now
-#               corrected to return only the dictionary of components.
+# DESCRIPTION:  Main application entry point. This definitive version correctly
+#               orchestrates UI layout, callback registration, and server launch.
+#
+# SETUP:        $ pip install -r requirements.txt
+#
+# AUTHOR:       An MCP & PhD Expert in Data & AI Solutions
+# VERSION:      5.3 (Definitive Launch Edition)
+# LAST-UPDATE:  2023-10-30 (Ensured main execution block and all callbacks are wired)
 
+import warnings
+import logging
 import gradio as gr
+
+# Import the UI layout and the callback LOGIC functions
+from ui.layout import create_main_layout
+from ui import callbacks
 from core.config import settings
 
-def create_main_layout() -> dict:
-    """
-    Defines the Gradio UI structure and returns a dictionary of its components.
+# --- Configuration & Setup ---
+# This setup MUST be in the global scope to be configured before any functions run.
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - [%(levelname)s] - (%(filename)s:%(lineno)d) - %(message)s'
+)
+warnings.filterwarnings('ignore', category=FutureWarning)
 
-    This function is designed to be called within a `gr.Blocks` context.
 
-    Returns:
-        A dictionary mapping component names to their Gradio component objects.
+def main():
+    """
+    Primary function to build, wire up, and launch the Gradio application.
     """
-    # State object to hold the DataAnalyzer instance
-    state_analyzer = gr.State()
+    logging.info(f"Starting {settings.APP_TITLE}")
+    
+    # The 'with' block creates the Gradio context. All UI and event listeners
+    # MUST be defined within this block.
+    with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="indigo"), title=settings.APP_TITLE) as demo:
+        
+        # 1. Build the UI from the layout module.
+        # This returns a dictionary of all named components.
+        components = create_main_layout()
 
-    # --- Header ---
-    gr.Markdown(f"<h1>{settings.APP_TITLE}</h1>")
-    gr.Markdown("A world-class data discovery platform that provides a complete suite of EDA tools and intelligently unlocks specialized analysis modules.")
+        # 2. Register all event handlers (callbacks) within the same context.
+        # This is the correct, robust pattern for a modular Gradio app.
 
-    # --- Input Row ---
-    with gr.Row():
-        upload_button = gr.File(label="1. Upload Data File (CSV, Excel)", file_types=[".csv", ".xlsx"], scale=3)
-        analyze_button = gr.Button("✨ Generate Intelligence Report", variant="primary", scale=1)
+        # --- Primary Analysis Chain ---
+        # Event 1: User clicks "Generate". This triggers the fast, initial analysis.
+        analysis_complete_event = components["analyze_button"].click(
+            fn=callbacks.run_initial_analysis,
+            inputs=[components["upload_button"]],
+            outputs=[components["state_analyzer"]]
+        )
 
-    # --- Main Tabs ---
-    with gr.Tabs():
-        with gr.Tab("🤖 AI-Powered Strategy Report", id="tab_ai"):
-            ai_report_output = gr.Markdown("### Your AI-generated report will appear here after analysis...")
-        
-        with gr.Tab("📋 Data Profile", id="tab_profile"):
-            with gr.Accordion("Missing Values Report", open=False):
-                profile_missing_df = gr.DataFrame()
-            with gr.Accordion("Numeric Features Summary", open=True):
-                profile_numeric_df = gr.DataFrame()
-            with gr.Accordion("Categorical Features Summary", open=True):
-                profile_categorical_df = gr.DataFrame()
+        # Event 2: Chained to the success of Event 1. This triggers the slower,
+        #          asynchronous report and visual generation.
+        analysis_complete_event.then(
+            fn=callbacks.generate_reports_and_visuals,
+            inputs=[components["state_analyzer"]],
+            outputs=components  # Maps the returned dict to the components dict
+        )
 
-        with gr.Tab("📊 Overview Visuals", id="tab_overview"):
-            with gr.Row():
-                plot_types = gr.Plot()
-                plot_missing = gr.Plot()
-            plot_correlation = gr.Plot()
-            
-        with gr.Tab("🎨 Interactive Explorer", id="tab_explorer"):
-             gr.Markdown("### Univariate Analysis")
-             with gr.Row():
-                 dd_hist_col = gr.Dropdown(label="Select Column for Histogram", interactive=True)
-                 plot_histogram = gr.Plot()
-             gr.Markdown("### Bivariate Analysis")
-             with gr.Row():
-                 with gr.Column(scale=1):
-                     dd_scatter_x = gr.Dropdown(label="X-Axis (Numeric)", interactive=True)
-                     dd_scatter_y = gr.Dropdown(label="Y-Axis (Numeric)", interactive=True)
-                     dd_scatter_color = gr.Dropdown(label="Color By (Optional)", interactive=True)
-                 with gr.Column(scale=2):
-                     plot_scatter = gr.Plot()
-        
-        with gr.Tab("🧩 Clustering (K-Means)", id="tab_cluster", visible=False) as tab_cluster:
-            with gr.Row():
-                with gr.Column(scale=1):
-                    num_clusters = gr.Slider(minimum=2, maximum=10, value=3, step=1, label="Number of Clusters (K)", interactive=True)
-                    md_cluster_summary = gr.Markdown()
-                with gr.Column(scale=2):
-                    plot_cluster = gr.Plot()
-            plot_elbow = gr.Plot()
-            
-        # Add other tabs as needed (Time-Series, Text)
-        tab_timeseries = gr.Tab("⌛ Time-Series Analysis", id="tab_timeseries", visible=False)
-        tab_text = gr.Tab("📝 Text Analysis", id="tab_text", visible=False)
+        # --- Interactive Explorer Callbacks ---
+        components["dd_hist_col"].change(
+            fn=callbacks.create_histogram,
+            inputs=[components["state_analyzer"], components["dd_hist_col"]],
+            outputs=[components["plot_histogram"]]
+        )
+
+        # For the scatter plot, we need to listen to changes on all three dropdowns.
+        scatter_inputs = [
+            components["state_analyzer"],
+            components["dd_scatter_x"],
+            components["dd_scatter_y"],
+            components["dd_scatter_color"]
+        ]
+        for dropdown in [components["dd_scatter_x"], components["dd_scatter_y"], components["dd_scatter_color"]]:
+            dropdown.change(
+                fn=callbacks.create_scatterplot,
+                inputs=scatter_inputs,
+                outputs=[components["plot_scatter"]]
+            )
+
+        # --- Specialized Module Callbacks ---
+        components["num_clusters"].change(
+            fn=callbacks.update_clustering,
+            inputs=[components["state_analyzer"], components["num_clusters"]],
+            outputs=[
+                components["plot_cluster"],
+                components["plot_elbow"],
+                components["md_cluster_summary"]
+            ]
+        )
+    
+    # 3. Launch the application server. This line is outside the 'with' block
+    #    but is called on the 'demo' object that was defined by it. The server
+    #    will now run indefinitely, listening for requests.
+    demo.launch(debug=False, server_name="0.0.0.0")
 
-    # Collect all components into a dictionary for easy access
-    components = {
-        # State
-        "state_analyzer": state_analyzer,
-        # Inputs
-        "upload_button": upload_button,
-        "analyze_button": analyze_button,
-        # AI Tab
-        "ai_report_output": ai_report_output,
-        # Profile Tab
-        "profile_missing_df": profile_missing_df,
-        "profile_numeric_df": profile_numeric_df,
-        "profile_categorical_df": profile_categorical_df,
-        # Overview Tab
-        "plot_types": plot_types,
-        "plot_missing": plot_missing,
-        "plot_correlation": plot_correlation,
-        # Explorer Tab
-        "dd_hist_col": dd_hist_col,
-        "plot_histogram": plot_histogram,
-        "dd_scatter_x": dd_scatter_x,
-        "dd_scatter_y": dd_scatter_y,
-        "dd_scatter_color": dd_scatter_color,
-        "plot_scatter": plot_scatter,
-        # Conditional Tabs
-        "tab_timeseries": tab_timeseries,
-        "tab_text": tab_text,
-        "tab_cluster": tab_cluster,
-        # Clustering Tab Components
-        "num_clusters": num_clusters,
-        "md_cluster_summary": md_cluster_summary,
-        "plot_cluster": plot_cluster,
-        "plot_elbow": plot_elbow,
-    }
 
-    return components
+# --- Application Entry Point ---
+# This is the most critical part for a runnable script. The `if __name__ == "__main__":`
+# check ensures that the `main()` function is called only when the script is
+# executed directly (not when it's imported by another script). Without this
+# block, the application will define the 'main' function but never run it,
+# leading to the "application not initialized" error.
+if __name__ == "__main__":
+    main()