app.py

# Odyssey - The AI Data Science Workspace
# A state-of-the-art, AI-native analytic environment.
# This script is a complete, self-contained Gradio application.

import gradio as gr
import pandas as pd
import numpy as np
import plotly.express as px
import plotly.graph_objects as go
import io, os, json, pickle, logging, warnings, uuid
from contextlib import redirect_stdout
from datetime import datetime

# ML & Preprocessing Imports
from sklearn.model_selection import cross_val_score, train_test_split
from sklearn.ensemble import RandomForestClassifier, RandomForestRegressor
from sklearn.linear_model import LogisticRegression, LinearRegression
from sklearn.metrics import roc_curve, auc, confusion_matrix, r2_score, mean_squared_error
from sklearn.preprocessing import LabelEncoder
from sklearn.impute import KNNImputer

# Optional: For AI features
try:
    import google.generativeai as genai
except ImportError:
    print("Warning: 'google-generativeai' not found. AI features will be disabled.")
    genai = None

# --- Configuration ---
warnings.filterwarnings('ignore')
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')

# --- UI Theme & Icons ---
THEME = gr.themes.Monochrome(primary_hue="indigo", secondary_hue="blue", neutral_hue="slate").set(
    body_background_fill="radial-gradient(circle, rgba(10,20,50,1) 0%, rgba(0,0,10,1) 100%);",
    block_label_background_fill="rgba(255,255,255,0.05)",
    block_background_fill="rgba(255,255,255,0.05)",
    button_primary_background_fill="linear-gradient(90deg, #6A11CB 0%, #2575FC 100%)",
    button_secondary_background_fill="linear-gradient(90deg, #556270 0%, #4ECDC4 100%)",
    color_accent_soft="rgba(255,255,255,0.2)"
)
ICONS = {"overview": "🔭", "medic": "🧪", "launchpad": "🚀", "copilot": "💡", "export": "📄"}

# --- Helper Functions ---
def safe_exec(code_string: str, local_vars: dict) -> tuple:
    """Safely execute a string of Python code and capture its output."""
    output_buffer = io.StringIO()
    try:
        with redirect_stdout(output_buffer):
            exec(code_string, globals(), local_vars)
        stdout = output_buffer.getvalue()
        fig = local_vars.get('fig')
        df_out = local_vars.get('df_result')
        return stdout, fig, df_out, None
    except Exception as e:
        return None, None, None, f"Execution Error: {str(e)}"

# --- Core State & Project Management ---
def init_state():
    """Initializes a blank global state dictionary."""
    return {
        "project_name": None, "df_original": None, "df_modified": None,
        "metadata": None, "insights": None, "chat_history": []
    }

def save_project(state):
    """Saves the entire application state to a .odyssey file."""
    if not state or not state.get("project_name"):
        return gr.update(value="Project needs a name to save.", interactive=True)
    
    filename = f"{state['project_name']}.odyssey"
    with open(filename, "wb") as f:
        pickle.dump(state, f)
    return gr.update(value=f"✅ Project saved to {filename}", interactive=True)

def load_project(file_obj):
    """Loads a .odyssey file into the application state."""
    if not file_obj: return init_state()
    with open(file_obj.name, "rb") as f:
        return pickle.load(f)

def prime_data(file_obj, project_name):
    """Main function to load a new CSV, analyze it, and set the initial state."""
    if not file_obj: return init_state()
    df = pd.read_csv(file_obj.name)
    
    for col in df.select_dtypes(include=['object']).columns:
        try:
            df[col] = pd.to_datetime(df[col], errors='raise')
        except (ValueError, TypeError):
            if 0.5 > df[col].nunique() / len(df) > 0.0:
                df[col] = df[col].astype('category')
    
    metadata = extract_metadata(df)
    insights = run_helios_engine(df, metadata)
    
    return {
        "project_name": project_name or f"Project_{datetime.now().strftime('%Y%m%d_%H%M')}",
        "df_original": df, "df_modified": df.copy(), "metadata": metadata,
        "insights": insights, "chat_history": []
    }

def extract_metadata(df):
    """Utility to get schema and column types."""
    return {
        'shape': df.shape, 'columns': df.columns.tolist(),
        'numeric': df.select_dtypes(include=np.number).columns.tolist(),
        'categorical': df.select_dtypes(include=['object', 'category']).columns.tolist(),
        'datetime': df.select_dtypes(include='datetime').columns.tolist(),
        'dtypes': df.dtypes.apply(lambda x: x.name).to_dict()
    }

# --- Module-Specific Handlers ---

def run_helios_engine(df, metadata):
    """The proactive analysis engine for the Helios Overview."""
    insights = {}
    missing = df.isnull().sum()
    insights['missing_data'] = missing[missing > 0].sort_values(ascending=False)
    insights['high_cardinality'] = {c: df[c].nunique() for c in metadata['categorical'] if df[c].nunique() > 50}
    
    outliers = {}
    for col in metadata['numeric']:
        Q1, Q3 = df[col].quantile(0.25), df[col].quantile(0.75)
        IQR = Q3 - Q1
        count = ((df[col] < (Q1 - 1.5 * IQR)) | (df[col] > (Q3 + 1.5 * IQR))).sum()
        if count > 0: outliers[col] = count
    insights['outliers'] = outliers
    
    suggestions = []
    for col in metadata['categorical']:
        if df[col].nunique() == 2: suggestions.append(f"{col} (Classification)")
    for col in metadata['numeric']:
        if df[col].nunique() > 20: suggestions.append(f"{col} (Regression)")
    insights['ml_suggestions'] = suggestions
    return insights

def prometheus_run_model(state, target, features, model_name):
    """Trains and evaluates a model in the Prometheus Launchpad."""
    if not target or not features: return None, None, "Select target and features."
    df = state['df_modified'].copy()
    df.dropna(subset=[target] + features, inplace=True)
    
    for col in [target] + features:
        if df[col].dtype.name in ['category', 'object']:
            df[col] = LabelEncoder().fit_transform(df[col])
            
    X, y = df[features], df[target]
    problem_type = "Classification" if y.nunique() <= 10 else "Regression"
    
    MODELS = {"Classification": {"Random Forest": RandomForestClassifier, "Logistic Regression": LogisticRegression},
              "Regression": {"Random Forest": RandomForestRegressor, "Linear Regression": LinearRegression}}
    if model_name not in MODELS[problem_type]: return None, None, "Invalid model for this problem type."
    
    model = MODELS[problem_type][model_name](random_state=42)
    
    if problem_type == "Classification":
        scores = cross_val_score(model, X, y, cv=5, scoring='accuracy')
        report = f"**Cross-Validated Accuracy:** {np.mean(scores):.3f} ± {np.std(scores):.3f}"
        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
        model.fit(X_train, y_train)
        y_prob = model.predict_proba(X_test)[:, 1]
        fpr, tpr, _ = roc_curve(y_test, y_prob)
        fig1 = go.Figure(data=go.Scatter(x=fpr, y=tpr, mode='lines', name=f'ROC (AUC = {auc(fpr, tpr):.2f})'))
        fig1.add_scatter(x=[0, 1], y=[0, 1], mode='lines', line=dict(dash='dash'), name='Random')
        fig1.update_layout(title="ROC Curve")
    else: # Regression
        scores = cross_val_score(model, X, y, cv=5, scoring='r2')
        report = f"**Cross-Validated R² Score:** {np.mean(scores):.3f} ± {np.std(scores):.3f}"
        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
        model.fit(X_train, y_train)
        preds = model.predict(X_test)
        residuals = y_test - preds
        fig1 = px.scatter(x=preds, y=residuals, title="Residuals vs. Predicted", labels={'x': 'Predicted', 'y': 'Residuals'})
        fig1.add_hline(y=0, line_dash="dash")
        
    if hasattr(model, 'feature_importances_'):
        fi = pd.Series(model.feature_importances_, index=features).sort_values(ascending=False)
        fig2 = px.bar(fi, title="Feature Importance")
    else:
        fig2 = go.Figure().update_layout(title="Feature Importance (Not available)")
        
    return fig1, fig2, report

def athena_respond(user_message, history, state, api_key):
    """Handles the chat interaction with the AI Co-pilot."""
    if not genai:
        history.append((user_message, "Google AI library not installed. Cannot use Athena."))
        return history, None, None, state
    if not api_key:
        history.append((user_message, "Please enter your Gemini API key to use Athena."))
        return history, None, None, state

    history.append((user_message, None))
    
    # Configure the API
    genai.configure(api_key=api_key)
    model = genai.GenerativeModel('gemini-1.5-flash')

    prompt = f"""
    You are 'Athena', an AI data scientist. Your goal is to help a user by writing and executing Python code on a pandas DataFrame named `df`.
    
    **DataFrame Info:**
    {state['df_modified'].info(verbose=False)}
    
    **Instructions:**
    1.  Analyze the user's request: '{user_message}'.
    2.  Formulate a plan (thought).
    3.  Write Python code to execute the plan. You can use `pandas as pd`, `numpy as np`, and `plotly.express as px`.
    4.  To show a plot, assign it to a variable `fig`.
    5.  To show a dataframe, assign it to a variable `df_result`.
    6.  Use `print()` for text output.
    7.  **NEVER** modify `df` in place.
    8.  Respond **ONLY** with a single, valid JSON object with keys "thought" and "code".
    
    **Your JSON Response:**
    """
    try:
        response = model.generate_content(prompt)
        response_json = json.loads(response.text.strip().replace("```json", "").replace("```", ""))
        thought = response_json.get("thought", "Thinking...")
        code_to_run = response_json.get("code", "print('No code generated.')")
        
        bot_thinking = f"🧠 **Thinking:** *{thought}*"
        history[-1] = (user_message, bot_thinking)
        yield history, None, None, state
        
        local_vars = {'df': state['df_modified'], 'px': px, 'pd': pd, 'np': np}
        stdout, fig_result, df_result, error = safe_exec(code_to_run, local_vars)

        bot_response = bot_thinking + "\n\n---\n\n"
        if error: bot_response += f"💥 **Error:**\n```\n{error}\n```"
        if stdout: bot_response += f"📋 **Output:**\n```\n{stdout}\n```"
        if not error and not stdout and not fig_result and not isinstance(df_result, pd.DataFrame):
            bot_response += "✅ Code executed, but produced no direct output."

        history[-1] = (user_message, bot_response)
        state['chat_history'] = history # Persist chat history
        yield history, fig_result, df_result, state
        
    except Exception as e:
        error_msg = f"A critical error occurred with the AI model: {e}"
        history[-1] = (user_message, error_msg)
        yield history, None, None, state

# --- UI Builder ---
def build_ui():
    """Constructs the entire Gradio application interface."""
    with gr.Blocks(theme=THEME, title="Odyssey AI Data Workspace") as demo:
        state = gr.State(init_state())

        with gr.Row():
            # Left Sidebar - Command Center
            with gr.Column(scale=1):
                gr.Markdown("# 🦉 Odyssey")
                with gr.Accordion("📂 Project", open=True):
                    project_name_input = gr.Textbox(label="Project Name", value="New_Project")
                    file_input = gr.File(label="Upload CSV", file_types=[".csv"])
                    api_key_input = gr.Textbox(label="🔑 Gemini API Key", type="password", placeholder="Enter key...")
                    with gr.Row():
                        save_btn = gr.Button("Save")
                        load_btn = gr.UploadButton("Load .odyssey")
                    project_status = gr.Markdown()
                
                # Navigation buttons
                overview_btn = gr.Button(f"{ICONS['overview']} Helios Overview")
                launchpad_btn = gr.Button(f"{ICONS['launchpad']} Prometheus Launchpad")
                copilot_btn = gr.Button(f"{ICONS['copilot']} Athena Co-pilot")
                export_btn = gr.Button(f"{ICONS['export']} Export Report", visible=False)

            # Right Panel - Main Workspace
            with gr.Column(scale=4):
                # --- Helios Overview Panel ---
                with gr.Column(visible=True) as overview_panel:
                    gr.Markdown(f"# {ICONS['overview']} Helios Overview")
                    helios_report_md = gr.Markdown("Upload a CSV and provide a project name to begin your Odyssey.")
                
                # --- Prometheus Launchpad Panel ---
                with gr.Column(visible=False) as launchpad_panel:
                    gr.Markdown(f"# {ICONS['launchpad']} Prometheus Launchpad")
                    with gr.Row():
                        lp_target = gr.Dropdown(label="🎯 Target")
                        # CORRECTED LINE: Use gr.Dropdown with multiselect=True
                        lp_features = gr.Dropdown(label="✨ Features", multiselect=True)
                        lp_model = gr.Dropdown(choices=["Random Forest", "Logistic Regression", "Linear Regression"], label="🧠 Model")
                    lp_run_btn = gr.Button("🚀 Launch Model Training (with CV)")
                    lp_report_md = gr.Markdown()
                    with gr.Row():
                        lp_fig1 = gr.Plot()
                        lp_fig2 = gr.Plot()
                
                # --- Athena Co-pilot Panel ---
                with gr.Column(visible=False) as copilot_panel:
                    gr.Markdown(f"# {ICONS['copilot']} Athena Co-pilot")
                    chatbot = gr.Chatbot(height=500, label="Chat History")
                    with gr.Accordion("AI Generated Results", open=True):
                        copilot_fig_output = gr.Plot()
                        copilot_df_output = gr.DataFrame(interactive=False)
                    chat_input = gr.Textbox(label="Your Request", placeholder="e.g., 'What's the correlation between all numeric columns?'")
                    chat_submit = gr.Button("Send", variant="primary")
        
        # --- Event Handling ---
        panels = [overview_panel, launchpad_panel, copilot_panel]
        def switch_panel(btn_idx):
            return [gr.update(visible=i == btn_idx) for i in range(len(panels))]
        
        overview_btn.click(lambda: switch_panel(0), None, panels)
        launchpad_btn.click(lambda: switch_panel(1), None, panels)
        copilot_btn.click(lambda: switch_panel(2), None, panels)

        def on_upload_or_load(state_data):
            """Unified function to update UI after data is loaded or a project is loaded."""
            helios_md = "No data loaded."
            if state_data and state_data.get('insights'):
                insights = state_data['insights']
                md = f"## 🔭 Proactive Insights for `{state_data.get('project_name')}`\n"
                md += f"Dataset has **{state_data['metadata']['shape'][0]} rows** and **{state_data['metadata']['shape'][1]} columns**.\n\n"
                if suggestions := insights.get('ml_suggestions'):
                    md += "### 🔮 Potential ML Targets\n" + "\n".join(f"- `{s}`" for s in suggestions) + "\n"
                if not insights.get('missing_data', pd.Series()).empty:
                    md += "\n### 💧 Missing Data\nFound missing values in these columns:\n" + insights['missing_data'].to_frame('Missing Count').to_markdown() + "\n"
                helios_md = md
            
            all_cols = state_data.get('metadata', {}).get('columns', [])
            return {
                state: state_data,
                helios_report_md: helios_md,
                lp_target: gr.update(choices=all_cols),
                lp_features: gr.update(choices=all_cols),
                chatbot: state_data.get('chat_history', [])
            }

        file_input.upload(prime_data, [file_input, project_name_input], state).then(
            on_upload_or_load, state, [state, helios_report_md, lp_target, lp_features, chatbot]
        )
        load_btn.upload(load_project, load_btn, state).then(
            on_upload_or_load, state, [state, helios_report_md, lp_target, lp_features, chatbot]
        )
        save_btn.click(save_project, state, project_status)
        
        lp_run_btn.click(prometheus_run_model, [state, lp_target, lp_features, lp_model], [lp_fig1, lp_fig2, lp_report_md])
        
        chat_submit.click(
            athena_respond,
            [chat_input, chatbot, state, api_key_input],
            [chatbot, copilot_fig_output, copilot_df_output, state]
        ).then(lambda: "", outputs=chat_input)

        return demo

# --- Main Execution ---
if __name__ == "__main__":
    app = build_ui()
    app.launch(debug=True)