Delete app.py

app.py

@@ -1,474 +0,0 @@
-# app.py (SparkNova Gradio Space - FIXED)
-import os
-import io
-import json
-import tempfile
-import traceback
-from io import BytesIO
-import pandas as pd
-import numpy as np
-import matplotlib.pyplot as plt
-import plotly.express as px
-import plotly.graph_objects as go
-import gradio as gr
-
-from langchain_groq import ChatGroq
-
-# ---------------- Config ----------------
-GROQ_API_KEY = os.getenv("GROQ_API_KEY", "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")
-os.environ["GROQ_API_KEY"] = GROQ_API_KEY
-
-# ---------------- Core Agent (UNCHANGED) ----------------
-llm = None
-uploaded_df = None
-dataset_name = None
-last_chart = None  # Store last generated chart
-
-SYSTEM_PROMPT = """You are a data analysis assistant. Respond ONLY in JSON describing a clear analysis plan.
-IMPORTANT: Only create plots when the user EXPLICITLY asks for visualization (chart, graph, plot, visualize, show distribution, etc.)
-For INFORMATIONAL queries (explain, describe, what is, tell me about, how many, etc.) - NO PLOT:
-{
-  "type": "explain",
-  "operations": [],
-  "plot": null,
-  "narrative": "detailed answer to the user's question",
-  "insights_needed": false
-}
-For STATISTICAL description WITHOUT visualization:
-{
-  "type": "describe",
-  "operations": [
-    {"op": "describe", "columns": ["col1"]}
-  ],
-  "plot": null,
-  "narrative": "statistical summary explanation",
-  "insights_needed": false
-}
-For VISUALIZATION requests (when user asks for chart/graph/plot):
-{
-  "type": "analysis",
-  "operations": [
-    {
-      "op": "groupby",
-      "columns": ["col1"],
-      "agg_col": "col2",
-      "agg_func": "mean"
-    }
-  ],
-  "plot": {"type": "bar"|"line"|"pie"|"hist", "x": "col1", "y": "result_col", "title": "..."},
-  "narrative": "short explanation",
-  "insights_needed": true
-}
-For filtering:
-{"op": "filter", "expr": "Age > 25"}
-For calculations:
-{"op": "calculate", "expr": "Col1 * Col2", "new_col": "Result"}
-Set "plot": null when user is asking informational questions without requesting visualization.
-"""
-
-def initialize_llm():
-    global llm
-    try:
-        llm = ChatGroq(model="llama-3.3-70b-versatile", api_key=GROQ_API_KEY, temperature=0.0)
-        print("GROQ API initialized")
-        return True
-    except Exception as e:
-        print("LLM init error:", e)
-        return False
-
-def clean_numeric(df):
-    df = df.copy()
-    for col in df.columns:
-        if pd.api.types.is_string_dtype(df[col]) or df[col].dtype == object:
-            s = df[col].astype(str).str.strip()
-            if s.str.contains("%", na=False).any():
-                numeric_vals = pd.to_numeric(s.str.replace("%", "", regex=False), errors="coerce")
-                if numeric_vals.notna().sum() / len(df) > 0.5:
-                    df[col] = numeric_vals / 100.0
-                    continue
-            cleaned = s.str.replace(",", "", regex=False).str.replace("₹", "", regex=False).str.replace("$", "", regex=False)
-            numeric_vals = pd.to_numeric(cleaned, errors="coerce")
-            if numeric_vals.notna().sum() / len(df) > 0.5:
-                df[col] = numeric_vals
-    return df
-
-def make_context(df):
-    sample_data = df.head(3).to_string(max_cols=10, max_colwidth=20)
-    return f"""Dataset: {len(df)} rows, {len(df.columns)} columns
-Columns: {', '.join(df.columns)}
-Data types: {df.dtypes.to_dict()}
-Sample data:
-{sample_data}"""
-
-def parse_plan(raw_text):
-    txt = raw_text.strip().replace("```json", "").replace("```", "").strip()
-    try:
-        start = txt.index("{")
-        end = txt.rindex("}") + 1
-        plan = json.loads(txt[start:end])
-        plan.setdefault("type", "analysis")
-        plan.setdefault("operations", [])
-        plan.setdefault("plot", None)
-        plan.setdefault("narrative", "")
-        plan.setdefault("insights_needed", False)
-        return plan
-    except Exception as e:
-        return {
-            "type": "error",
-            "operations": [],
-            "plot": None,
-            "narrative": f"Error parsing LLM response: {str(e)}",
-            "insights_needed": False
-        }
-
-def execute_plan(df, plan):
-    dfw = df.copy()
-    describe_stats = {}
-    try:
-        for op in plan.get("operations", []):
-            optype = op.get("op", "").lower()
-            if optype == "describe":
-                cols = op.get("columns", [])
-                for col in cols:
-                    if col in dfw.columns:
-                        stats = dfw[col].describe()
-                        describe_stats[col] = stats
-            elif optype == "groupby":
-                cols = op.get("columns", [])
-                agg_col = op.get("agg_col")
-                agg_func = op.get("agg_func", "count")
-                if not cols:
-                    continue
-                if agg_func == "count" or not agg_col:
-                    dfw = dfw.groupby(cols).size().reset_index(name="count")
-                else:
-                    if agg_col in dfw.columns:
-                        result_col = f"{agg_func}_{agg_col}"
-                        dfw = dfw.groupby(cols)[agg_col].agg(agg_func).reset_index(name=result_col)
-            elif optype == "filter":
-                expr = op.get("expr", "")
-                if expr:
-                    dfw = dfw.query(expr)
-            elif optype == "calculate":
-                expr = op.get("expr", "")
-                new_col = op.get("new_col", "Calculated")
-                dfw[new_col] = dfw.eval(expr)
-        return dfw, describe_stats
-    except Exception as e:
-        raise Exception(f"Execution error: {str(e)}")
-
-def create_plot(df, dfw, plan, describe_stats):
-    global last_chart
-    plot_spec = plan.get("plot")
-    if not plot_spec:
-        last_chart = None
-        return None
-    ptype = plot_spec.get("type", "bar")
-    x = plot_spec.get("x")
-    y = plot_spec.get("y")
-    title = plot_spec.get("title", "Chart")
-    plot_df = df if describe_stats else dfw
-    if x and x not in plot_df.columns:
-        x = None
-    if y and y not in plot_df.columns:
-        numeric_cols = plot_df.select_dtypes(include=[np.number]).columns
-        y = numeric_cols[0] if len(numeric_cols) > 0 else None
-    if not y:
-        last_chart = None
-        return None
-    try:
-        if ptype == "pie":
-            df_pie = plot_df.set_index(x)[y] if x else plot_df[y]
-            df_pie = df_pie.dropna()
-            fig = go.Figure(data=[go.Pie(labels=df_pie.index, values=df_pie.values, textposition='none')])
-            fig.update_layout(title=title, title_font_size=16, showlegend=True, width=900, height=500)
-        elif ptype == "bar":
-            if x:
-                fig = px.bar(plot_df, x=x, y=y, title=title)
-            else:
-                fig = px.bar(y=plot_df[y], title=title)
-            fig.update_layout(width=900, height=500)
-        elif ptype == "line":
-            if x:
-                fig = px.line(plot_df, x=x, y=y, title=title, markers=True)
-            else:
-                fig = px.line(y=plot_df[y], title=title, markers=True)
-            fig.update_layout(width=900, height=500)
-        elif ptype == "hist":
-            fig = px.histogram(plot_df, x=y, title=title, nbins=20)
-            fig.update_layout(width=900, height=500)
-        elif ptype == "box":
-            fig = px.box(plot_df, y=y, x=x, title=title) if x else px.box(plot_df, y=y, title=title)
-            fig.update_layout(width=900, height=500)
-        elif ptype == "heatmap":
-            numeric = plot_df.select_dtypes(include=[np.number])
-            if numeric.shape[1] < 2:
-                last_chart = None
-                return None
-            corr = numeric.corr()
-            fig = px.imshow(corr, text_auto=True, title=title)
-            fig.update_layout(width=900, height=500)
-        else:
-            last_chart = None
-            return None
-        
-        last_chart = fig
-        return fig
-    except Exception as e:
-        print(f"Plot error: {e}")
-        last_chart = None
-        return None
-
-def generate_insights(df, dfw, plan):
-    try:
-        context_parts = []
-        for op in plan.get("operations", []):
-            if op.get("op") == "describe":
-                cols = op.get("columns", [])
-                for col in cols:
-                    if col in df.columns:
-                        desc = df[col].describe()
-                        context_parts.append(f"\n{col} Statistics:\n{desc.to_string()}")
-            elif op.get("op") == "groupby":
-                context_parts.append(f"\nGrouped Results:\n{dfw.head(10).to_string()}")
-        if len(dfw) > 0:
-            context_parts.append(f"\nResult Preview:\n{dfw.head(10).to_string()}")
-        insights_context = "\n".join(context_parts)
-        insights_prompt = f"""Based on this analysis, provide 4-6 detailed bullet points explaining key insights, patterns, and findings.
-Analysis Context:
-{insights_context}
-Original Question Context:
-{plan.get('narrative', '')}
-Provide insights as bullet points."""
-        response = llm.invoke([
-            {"role": "system", "content": "You are a data insights expert."},
-            {"role": "user", "content": insights_prompt}
-        ])
-        return response.content if hasattr(response, 'content') else str(response)
-    except Exception as e:
-        return f"Error generating insights: {str(e)}"
-
-def analyze_question(question):
-    global uploaded_df, llm
-    if llm is None:
-        return "API not initialized. Please restart the application.", None, None
-    if uploaded_df is None:
-        return "Please upload a dataset first.", None, None
-    if not question.strip():
-        return "Please enter a question.", None, None
-    try:
-        data_ctx = make_context(uploaded_df)
-        user_msg = f"{question}\n\nDataset Context:\n{data_ctx}"
-        messages = [
-            {"role": "system", "content": SYSTEM_PROMPT},
-            {"role": "user", "content": user_msg}
-        ]
-        response = llm.invoke(messages)
-        raw_text = response.content if hasattr(response, 'content') else str(response)
-        plan = parse_plan(raw_text)
-        if plan.get("type") == "explain":
-            return plan.get("narrative", "No explanation provided"), None, None
-        if plan.get("type") == "error":
-            return plan.get("narrative", "Error occurred"), None, None
-        dfw, describe_stats = execute_plan(uploaded_df, plan)
-        response_text = plan.get("narrative", "Analysis complete")
-        if describe_stats:
-            response_text += "\n\n Statistical Summary:\n"
-            for col, stats in describe_stats.items():
-                response_text += f"\n{col}:\n{stats.to_string()}\n"
-        fig = None
-        if plan.get("plot"):
-            fig = create_plot(uploaded_df, dfw, plan, describe_stats)
-            if fig:
-                response_text += "\n\n Chart generated successfully!"
-        if plan.get("insights_needed") and fig:
-            insights = generate_insights(uploaded_df, dfw, plan)
-            response_text += f"\n\n Key Insights:\n{insights}"
-        result_table = None
-        if not describe_stats and len(dfw) != len(uploaded_df):
-            result_table = dfw.head(50)
-        return response_text, fig, result_table
-    except Exception as e:
-        return f"Error during analysis: {str(e)}", None, None
-
-# ---------------- UI (Gradio) ----------------
-custom_css = """
-.gradio-container { max-width: 1200px !important; margin: 0 auto !important; }
-.header-box { background: linear-gradient(135deg, #f6f0ff 0%, #fff0fb 100%); border: 2px solid #e9d8ff; border-radius: 12px; padding: 18px; text-align: center;}
-.left-panel { background:#f7f7fb; border-radius:10px; padding:12px; height:100%; }
-.right-panel { background:#ffffff; border-radius:10px; padding:12px; height:100%; box-shadow: 0 6px 18px rgba(20,20,20,0.04); }
-.section-title { font-weight:600; font-size:16px; margin-bottom:8px; }
-.tools-vertical .gr-button { width:100%; margin-bottom:8px; text-align:left; }
-.small-muted { font-size:12px; color:#666; }
-.result-box { border:1px solid #eee; border-radius:8px; padding:10px; background:#fafafa; min-height:120px; }
-"""
-
-with gr.Blocks(theme=gr.themes.Soft(primary_hue="purple"), css=custom_css) as demo:
-    gr.HTML("<div class='header-box'><h1 style='margin:0;color:#5B21B6;'>SparkNova</h1><div style='margin-top:6px;color:#666;font-style:italic;'>An AI-powered data exploration and insight generator</div></div>")
-
-    with gr.Row():
-        with gr.Column(scale=2):
-            file_input = gr.File(label="Upload CSV", file_types=[".csv"])
-            format_select = gr.Dropdown(["Preview","JSON","CSV","Excel"], value="Preview", label="Show preview as")
-            dataset_info = gr.Markdown()
-            dataset_preview = gr.Dataframe(wrap=True, label="Dataset Preview")
-        with gr.Column(scale=3):
-            gr.Markdown("### Sample Questions")
-            gr.Markdown("- What is the average value of numeric columns?\n- Show a bar chart of sales by region\n- Which column correlates most with revenue?\n- Generate a pie chart for product categories\n- Find missing values\n- Create a line chart showing trends over time\n- Top 5 values in the dataset\n- Show statistical summary of all columns", elem_classes="small-muted")
-
-    # Hook upload to handler
-    def upload_handler(file, fmt):
-        global uploaded_df, dataset_name
-        if file is None:
-            return "No file uploaded", None
-        try:
-            uploaded_df = pd.read_csv(file.name)
-            uploaded_df = clean_numeric(uploaded_df)
-            dataset_name = os.path.basename(file.name)
-            info_text = f"**Dataset Loaded:** {dataset_name} — {uploaded_df.shape[0]} rows × {uploaded_df.shape[1]} cols"
-            preview_df = uploaded_df.head(10)
-            return info_text, preview_df
-        except Exception as e:
-            return f"Error loading file: {e}", None
-
-    file_input.change(upload_handler, inputs=[file_input, format_select], outputs=[dataset_info, dataset_preview])
-
-    with gr.Row():
-        with gr.Column(scale=1, elem_classes="left-panel"):
-            gr.Markdown("#### Choose an Analysis Type", elem_classes="section-title")
-            btn_describe = gr.Button("Describe Dataset")
-            btn_summary = gr.Button("Summary Statistics")
-            btn_corr = gr.Button("Show Correlations")
-            btn_top5 = gr.Button("Top 5 Rows")
-            btn_missing = gr.Button("Missing Values")
-            btn_groupby = gr.Button("Group & Aggregate")
-            btn_calc = gr.Button("Calculate Expression")
-            btn_find = gr.Button("Find Highest Correlation")
-            gr.Markdown("#### Visualization Types", elem_classes="section-title")
-            chart_bar = gr.Button("Bar Chart")
-            chart_line = gr.Button("Line Chart")
-            chart_scatter = gr.Button("Scatter Plot")
-            chart_pie = gr.Button("Pie Chart")
-            chart_hist = gr.Button("Histogram")
-            chart_box = gr.Button("Box Plot")
-            chart_heat = gr.Button("Heatmap")
-            gr.Markdown("#### Other", elem_classes="section-title")
-            btn_insights = gr.Button("Generate Insights (LLM)")
-            btn_reload = gr.Button("Reload Dataset")
-        
-        with gr.Column(scale=2, elem_classes="right-panel"):
-            gr.Markdown("#### Analysis Output", elem_classes="section-title")
-            output_text = gr.Textbox(label="Detailed Response", interactive=False, lines=10, show_copy_button=True)
-            gr.Markdown("#### Result Data", elem_classes="section-title")
-            result_table = gr.Dataframe(wrap=True, interactive=False)
-            gr.Markdown("#### Chart Preview", elem_classes="section-title")
-            chart_display = gr.Plot()
-            chart_explain = gr.Markdown("Chart explanation will appear here.")
-            gr.Markdown("#### Ask a Question (LLM)", elem_classes="section-title")
-            question_box = gr.Textbox(label="Type your question here", lines=3, placeholder="Ask the agent (LLM)...")
-            ask_btn = gr.Button("Ask (LLM)", variant="primary")
-
-    # Map actions to natural language questions
-    action_map = {
-        "Describe Dataset": "Describe the dataset statistically.",
-        "Summary Statistics": "Provide summary statistics for all columns.",
-        "Show Correlations": "Which columns have the highest correlation? Provide correlation table.",
-        "Top 5 Rows": "Show the top 5 rows of the dataset.",
-        "Missing Values": "List missing values in each column.",
-        "Group & Aggregate": "Group data and compute typical aggregations (provide example groupby).",
-        "Calculate Expression": "Create a calculated column (example: create Col_Calc = ColA * ColB).",
-        "Find Highest Correlation": "Which column has highest correlation with revenue?",
-        "Generate Insights (LLM)": "Generate short insights for the dataset (4-6 bullets)."
-    }
-
-    def run_action(action_label):
-        if uploaded_df is None:
-            return "Please upload a dataset first.", None, None
-        question = action_map.get(action_label, action_label)
-        text, fig, table = analyze_question(question)
-        return text, fig, table
-
-    # Connect buttons
-    btn_describe.click(lambda: run_action("Describe Dataset"), outputs=[output_text, chart_display, result_table])
-    btn_summary.click(lambda: run_action("Summary Statistics"), outputs=[output_text, chart_display, result_table])
-    btn_corr.click(lambda: run_action("Show Correlations"), outputs=[output_text, chart_display, result_table])
-    btn_top5.click(lambda: run_action("Top 5 Rows"), outputs=[output_text, chart_display, result_table])
-    btn_missing.click(lambda: run_action("Missing Values"), outputs=[output_text, chart_display, result_table])
-    btn_groupby.click(lambda: run_action("Group & Aggregate"), outputs=[output_text, chart_display, result_table])
-    btn_calc.click(lambda: run_action("Calculate Expression"), outputs=[output_text, chart_display, result_table])
-    btn_find.click(lambda: run_action("Find Highest Correlation"), outputs=[output_text, chart_display, result_table])
-    btn_insights.click(lambda: run_action("Generate Insights (LLM)"), outputs=[output_text, chart_display, result_table])
-    btn_reload.click(lambda: upload_handler(file_input, format_select), outputs=[dataset_info, dataset_preview])
-
-    # Chart requests
-    def request_chart(chart_type):
-        if uploaded_df is None:
-            return "Please upload dataset first.", None, "No explanation"
-        q = f"Please produce a {chart_type} showing something meaningful from the dataset. Include a plot specification in the JSON."
-        text, fig, table = analyze_question(q)
-        explanation = f"This is a {chart_type} generated by the agent."
-        return text, fig, explanation
-
-    chart_bar.click(lambda: request_chart("bar"), outputs=[output_text, chart_display, chart_explain])
-    chart_line.click(lambda: request_chart("line"), outputs=[output_text, chart_display, chart_explain])
-    chart_scatter.click(lambda: request_chart("scatter"), outputs=[output_text, chart_display, chart_explain])
-    chart_pie.click(lambda: request_chart("pie"), outputs=[output_text, chart_display, chart_explain])
-    chart_hist.click(lambda: request_chart("hist"), outputs=[output_text, chart_display, chart_explain])
-    chart_box.click(lambda: request_chart("box"), outputs=[output_text, chart_display, chart_explain])
-    chart_heat.click(lambda: request_chart("heatmap"), outputs=[output_text, chart_display, chart_explain])
-
-    # Freeform question via LLM
-    def ask_freeform(q):
-        if uploaded_df is None:
-            return "Please upload a dataset first.", None, None
-        return analyze_question(q)
-
-    ask_btn.click(ask_freeform, inputs=[question_box], outputs=[output_text, chart_display, result_table])
-
-    # --------------------- Download Section (FIXED) ---------------------
-    gr.Markdown("###  Download Options")
-    
-    # Define download functions with proper state management
-    def download_result_data():
-        """Download the result table as CSV"""
-        if uploaded_df is None:
-            return None
-        try:
-            temp_file = tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.csv', newline='')
-            uploaded_df.to_csv(temp_file.name, index=False)
-            return temp_file.name
-        except Exception as e:
-            print(f"Error saving results: {e}")
-            return None
-    
-    def download_chart_image():
-        """Download the last generated chart as PNG"""
-        global last_chart
-        if last_chart is None:
-            return None
-        try:
-            temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.png')
-            last_chart.write_image(temp_file.name, width=1200, height=700)
-            return temp_file.name
-        except Exception as e:
-            print(f"Error saving chart: {e}")
-            return None
-    
-    # Create file outputs
-    result_file_output = gr.File(label="Download Results", visible=True)
-    chart_file_output = gr.File(label="Download Chart", visible=True)
-    
-    # Buttons with proper outputs
-    download_result_btn = gr.Button(" Download Results CSV", variant="secondary")
-    download_chart_btn = gr.Button(" Download Chart PNG", variant="secondary")
-    
-    # Connect buttons
-    download_result_btn.click(download_result_data, inputs=[], outputs=[result_file_output])
-    download_chart_btn.click(download_chart_image, inputs=[], outputs=[chart_file_output])
-
-    gr.HTML("<div style='text-align:center;color:#666;padding-top:10px;'>Powered by GROQ LLM & Gradio — SparkNova</div>")
-
-# Initialize LLM and launch
-if __name__ == "__main__":
-    initialize_llm()
-    demo.launch(server_name="0.0.0.0", server_port=7860, debug=True)