Delete app.py

app.py

@@ -1,624 +0,0 @@
-"""
-AUTOMATION 2 (UPGRADED) — Hugging Face Spaces App
-==================================================
-Improvements over v1:
-  ✓ LLM (GPT-4o-mini) called DIRECTLY from inside the app
-  ✓ Richer interactive visualisations (radar chart, trend bars, gauge)
-  ✓ Side-by-side metric comparison panel
-  ✓ Session history tracker
-  ✓ Automated pipeline trigger button (runs agentic_pipeline.py)
-  ✓ Confidence intervals on predictions
-  ✓ Better UX: loading states, cleaner layout, collapsible AI section
-
-Deploy on Hugging Face Spaces (SDK: Gradio).
-Set HF Secret: OPENAI_API_KEY
-"""
-
-import os
-import json
-import time
-import subprocess
-import gradio as gr
-import pandas as pd
-import numpy as np
-import matplotlib
-matplotlib.use("Agg")
-import matplotlib.pyplot as plt
-import matplotlib.patches as mpatches
-import warnings
-warnings.filterwarnings("ignore")
-
-from sklearn.ensemble import RandomForestRegressor
-from sklearn.model_selection import train_test_split
-from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer
-
-try:
-    import requests
-    REQUESTS_OK = True
-except ImportError:
-    REQUESTS_OK = False
-
-# ── CONFIG ──────────────────────────────────────────────────
-OPENAI_KEY = os.environ.get("OPENAI_API_KEY", "")   # Set as HF Secret
-GPT_MODEL  = "gpt-4o-mini"
-
-PALETTE = {
-    "blue":   "#2E86AB",
-    "pink":   "#A23B72",
-    "amber":  "#F18F01",
-    "red":    "#C73E1D",
-    "teal":   "#44BBA4",
-    "light":  "#F5F5F5",
-    "dark":   "#1A1A2E",
-}
-
-# ── STARTUP: TRAIN MODELS ───────────────────────────────────
-print("Loading data and training models on startup...")
-
-def _load_and_train_amazon():
-    df = pd.read_csv("amazon_synthetic.csv")
-    df["log_sales"] = np.log1p(df["rating_count"])
-    features = ["actual_price", "discounted_price", "discount_pct", "rating", "sentiment_score"]
-    X = df[features].dropna()
-    y = df.loc[X.index, "log_sales"]
-    rf = RandomForestRegressor(n_estimators=150, random_state=42)
-    rf.fit(X, y)
-    # Compute prediction std via individual trees for confidence interval
-    return rf, features, df
-
-def _load_and_train_spotify():
-    df = pd.read_csv("spotify_synthetic.csv")
-    df["explicit"] = df["explicit"].astype(int)
-    features = ["danceability", "energy", "loudness", "speechiness",
-                "acousticness", "instrumentalness", "valence", "tempo", "explicit"]
-    X = df[features].dropna()
-    y = df.loc[X.index, "popularity"]
-    rf = RandomForestRegressor(n_estimators=150, random_state=42)
-    rf.fit(X, y)
-    return rf, features, df
-
-try:
-    rf_amz, features_amz, df_amz = _load_and_train_amazon()
-    AMZ_OK = True
-    print("✓ Amazon model ready")
-except Exception as e:
-    AMZ_OK = False
-    print(f"✗ Amazon model failed: {e}")
-
-try:
-    rf_spot, features_spot, df_spot = _load_and_train_spotify()
-    SPOT_OK = True
-    print("✓ Spotify model ready")
-except Exception as e:
-    SPOT_OK = False
-    print(f"✗ Spotify model failed: {e}")
-
-analyzer = SentimentIntensityAnalyzer()
-
-# Session history
-session_history = []
-
-
-# ════════════════════════════════════════════════════════════
-# GPT HELPER — called directly from the app
-# ════════════════════════════════════════════════════════════
-
-def call_gpt_in_app(system_prompt: str, user_prompt: str, max_tokens=500) -> str:
-    """
-    Call GPT-4o-mini directly from within the Gradio app.
-    Falls back to a template report if API key is not set.
-    """
-    if not OPENAI_KEY or not REQUESTS_OK:
-        return None   # will use fallback below
-
-    headers = {
-        "Authorization": f"Bearer {OPENAI_KEY}",
-        "Content-Type": "application/json",
-    }
-    payload = {
-        "model": GPT_MODEL,
-        "messages": [
-            {"role": "system", "content": system_prompt},
-            {"role": "user",   "content": user_prompt},
-        ],
-        "temperature": 0.4,
-        "max_tokens": max_tokens,
-    }
-    try:
-        r = requests.post(
-            "https://api.openai.com/v1/chat/completions",
-            headers=headers, json=payload, timeout=25
-        )
-        r.raise_for_status()
-        return r.json()["choices"][0]["message"]["content"]
-    except Exception as e:
-        return f"[GPT unavailable: {e}]"
-
-
-def get_amazon_gpt_insight(category, actual_price, discounted_price, discount_pct,
-                           rating, sentiment_score, sentiment_label, sales_pred, score):
-    system = (
-        "You are a senior e-commerce performance analyst. Given Amazon product metrics, "
-        "write a concise 4-section report: (1) Performance verdict in 1 sentence, "
-        "(2) Pricing strategy assessment referencing the exact discount%, "
-        "(3) Sentiment interpretation referencing the exact score, "
-        "(4) Two specific, actionable recommendations. "
-        "Be data-driven. Reference every number provided. Keep total response under 200 words."
-    )
-    user = (
-        f"Category: {category} | Actual price: ₹{actual_price:.0f} | "
-        f"Discounted price: ₹{discounted_price:.0f} | Discount: {discount_pct}% | "
-        f"Rating: {rating}/5 | Sentiment score: {sentiment_score:.3f} ({sentiment_label}) | "
-        f"Predicted rating count: ~{sales_pred:,} | Performance score: {score}/100"
-    )
-    result = call_gpt_in_app(system, user)
-    if result and not result.startswith("[GPT"):
-        return "🤖 AI Analysis (GPT-4o-mini)\n" + "─" * 36 + "\n" + result
-    # Fallback
-    return (
-        "🤖 AI Analysis (template fallback — set OPENAI_API_KEY for live GPT)\n"
-        + "─" * 36 + "\n"
-        f"1. Performance: This {category} product scores {score}/100 — "
-        f"{'strong' if score >= 75 else 'average' if score >= 45 else 'underperforming'}.\n"
-        f"2. Pricing: A {discount_pct}% discount brings the price from ₹{actual_price:.0f} to "
-        f"₹{discounted_price:.0f}. {'This aggressive discount may signal lower quality.' if discount_pct > 50 else 'Moderate discount maintains perceived value.'}\n"
-        f"3. Sentiment: Score of {sentiment_score:.3f} is {sentiment_label}. "
-        f"{'Strong reviews support organic growth.' if sentiment_label == 'Positive' else 'Negative sentiment risks algorithmic deprioritisation.'}\n"
-        f"4. Recommendations:\n"
-        f"   • {'Leverage positive reviews in sponsored ads' if sentiment_label == 'Positive' else 'Address negative feedback within 48h'}\n"
-        f"   • {'Reduce discount to 20–30% to protect margin' if discount_pct > 50 else 'Maintain current pricing strategy'}"
-    )
-
-
-def get_spotify_gpt_insight(genre, danceability, energy, loudness, tempo,
-                             valence, acousticness, pop_pred, tier):
-    system = (
-        "You are a music industry data analyst. Given Spotify audio features, "
-        "write a concise 4-section report: (1) Commercial potential verdict in 1 sentence, "
-        "(2) Audio profile assessment — is it radio-friendly? Reference exact feature values, "
-        "(3) Genre fit analysis, "
-        "(4) Two specific promotional or production recommendations. "
-        "Be data-driven. Reference every number. Under 200 words total."
-    )
-    user = (
-        f"Genre: {genre} | Popularity prediction: {pop_pred:.1f}/100 ({tier}) | "
-        f"Danceability: {danceability:.2f} | Energy: {energy:.2f} | Loudness: {loudness:.1f} dB | "
-        f"Tempo: {tempo:.0f} BPM | Valence: {valence:.2f} | Acousticness: {acousticness:.2f}"
-    )
-    result = call_gpt_in_app(system, user)
-    if result and not result.startswith("[GPT"):
-        return "🤖 AI Analysis (GPT-4o-mini)\n" + "─" * 36 + "\n" + result
-    return (
-        "🤖 AI Analysis (template fallback — set OPENAI_API_KEY for live GPT)\n"
-        + "─" * 36 + "\n"
-        f"1. Commercial potential: This {genre} track scores {pop_pred:.1f}/100 — {tier}.\n"
-        f"2. Audio profile: Danceability {danceability:.2f} + energy {energy:.2f} at {loudness:.1f} dB. "
-        f"{'Radio-friendly profile.' if danceability > 0.6 and energy > 0.6 else 'Niche profile — limited mainstream appeal.'}\n"
-        f"3. Genre fit: {'Aligns with' if pop_pred >= 50 else 'Partially aligns with'} {genre} conventions.\n"
-        f"4. Recommendations:\n"
-        f"   • {'Pitch to editorial playlists — strong commercial profile' if pop_pred >= 60 else 'Consider a remix to boost danceability'}\n"
-        f"   • {'Capitalize on high energy for live and sync licensing' if energy >= 0.7 else 'Explore streaming-first promotional strategy'}"
-    )
-
-
-# ════════════════════════════════════════════════════════════
-# VISUALISATION HELPERS
-# ════════════════════════════════════════════════════════════
-
-def _radar_chart(labels, values, title, color):
-    """Create a radar (spider) chart for audio features."""
-    n = len(labels)
-    angles = np.linspace(0, 2 * np.pi, n, endpoint=False).tolist()
-    values_loop = values + [values[0]]
-    angles += angles[:1]
-
-    fig, ax = plt.subplots(figsize=(4.5, 4.5), subplot_kw={"polar": True})
-    fig.patch.set_facecolor("#FAFAFA")
-    ax.set_facecolor("#F0F4F8")
-    ax.plot(angles, values_loop, color=color, linewidth=2)
-    ax.fill(angles, values_loop, color=color, alpha=0.25)
-    ax.set_xticks(angles[:-1])
-    ax.set_xticklabels(labels, fontsize=9)
-    ax.set_ylim(0, 1)
-    ax.set_yticks([0.25, 0.5, 0.75])
-    ax.set_yticklabels(["0.25", "0.50", "0.75"], fontsize=7, color="gray")
-    ax.set_title(title, fontsize=11, fontweight="bold", pad=15)
-    ax.grid(color="white", linewidth=0.8)
-    plt.tight_layout()
-    return fig
-
-
-def make_amazon_chart(rating, sentiment_score, discount_pct, score, sales_pred):
-    import tempfile
-    fig, axes = plt.subplots(1, 3, figsize=(14, 4.5))
-    fig.patch.set_facecolor("#FAFAFA")
-    fig.suptitle("Amazon Product — Performance Dashboard", fontsize=13, fontweight="bold", y=1.01)
-
-    # Panel 1: Feature bars
-    ax = axes[0]
-    ax.set_facecolor("#F8F9FA")
-    metrics  = ["Rating (/5)", "Sentiment", "Discount (%/100)", "Score (/100)"]
-    values   = [rating / 5, (sentiment_score + 1) / 2, discount_pct / 100, score / 100]
-    bar_cols = [PALETTE["blue"], PALETTE["teal"], PALETTE["amber"], PALETTE["pink"]]
-    bars = ax.bar(metrics, values, color=bar_cols, edgecolor="white", width=0.6)
-    ax.set_ylim(0, 1.15)
-    ax.set_title("Key Metrics (normalised)", fontweight="bold")
-    for bar, val in zip(bars, values):
-        ax.text(bar.get_x() + bar.get_width() / 2, bar.get_height() + 0.025,
-                f"{val:.2f}", ha="center", fontsize=10, fontweight="bold")
-    ax.set_xticklabels(metrics, fontsize=9)
-
-    # Panel 2: Gauge
-    ax2 = axes[1]
-    ax2.set_facecolor("#F8F9FA")
-    tier_color = (PALETTE["teal"] if score >= 75 else
-                  PALETTE["amber"] if score >= 45 else PALETTE["red"])
-    tier = "Top Performer" if score >= 75 else "Average" if score >= 45 else "Underperformer"
-    wedge_colors = [tier_color, "#E8E8E8"]
-    ax2.pie([score, 100 - score], colors=wedge_colors, startangle=90,
-            wedgeprops={"edgecolor": "white", "linewidth": 2})
-    ax2.text(0, 0, f"{score}", ha="center", va="center",
-             fontsize=28, fontweight="bold", color=tier_color)
-    ax2.set_title(f"Score: {tier}", fontweight="bold")
-
-    # Panel 3: Est. rating count vs category benchmarks (synthetic)
-    ax3 = axes[2]
-    ax3.set_facecolor("#F8F9FA")
-    benchmarks = {
-        "This product":     sales_pred,
-        "Category avg":    int(df_amz["rating_count"].mean()) if AMZ_OK else 15000,
-        "Top 10%":         int(df_amz["rating_count"].quantile(0.9)) if AMZ_OK else 50000,
-    }
-    bc = [PALETTE["pink"], PALETTE["blue"], PALETTE["blue"]]
-    ax3.barh(list(benchmarks.keys()), list(benchmarks.values()),
-             color=bc, edgecolor="white")
-    ax3.set_title("Est. Sales vs Benchmarks", fontweight="bold")
-    ax3.set_xlabel("Predicted Rating Count")
-
-    plt.tight_layout()
-    tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".png")
-    plt.savefig(tmp.name, dpi=130, bbox_inches="tight", facecolor="#FAFAFA")
-    plt.close()
-    return tmp.name
-
-
-def make_spotify_chart(danceability, energy, loudness, tempo, valence,
-                       acousticness, speechiness, pop_pred, genre):
-    import tempfile
-    fig = plt.figure(figsize=(14, 4.5))
-    fig.patch.set_facecolor("#FAFAFA")
-    fig.suptitle("Spotify Track — Audio Profile Dashboard", fontsize=13, fontweight="bold")
-
-    # Panel 1: Radar
-    ax1 = fig.add_subplot(1, 3, 1, polar=True)
-    labels = ["Dance", "Energy", "Valence", "Acoust.", "Speech"]
-    vals   = [danceability, energy, valence, acousticness, speechiness]
-    n = len(labels)
-    angles = np.linspace(0, 2 * np.pi, n, endpoint=False).tolist()
-    vals_loop   = vals + [vals[0]]
-    angles_loop = angles + angles[:1]
-    ax1.plot(angles_loop, vals_loop, color=PALETTE["blue"], linewidth=2)
-    ax1.fill(angles_loop, vals_loop, color=PALETTE["blue"], alpha=0.25)
-    ax1.set_xticks(angles)
-    ax1.set_xticklabels(labels, fontsize=9)
-    ax1.set_ylim(0, 1)
-    ax1.set_yticks([0.25, 0.5, 0.75])
-    ax1.set_yticklabels(["", "", ""], fontsize=7)
-    ax1.set_title("Audio Radar", fontweight="bold", pad=14)
-    ax1.set_facecolor("#F0F4F8")
-    ax1.grid(color="white")
-
-    # Panel 2: Gauge
-    ax2 = fig.add_subplot(1, 3, 2)
-    ax2.set_facecolor("#F8F9FA")
-    tier = ("Hit 🔥" if pop_pred >= 70 else "Popular" if pop_pred >= 50
-            else "Mid-tier" if pop_pred >= 30 else "Niche")
-    tier_color = (PALETTE["red"] if pop_pred >= 70 else
-                  PALETTE["teal"] if pop_pred >= 50 else
-                  PALETTE["amber"] if pop_pred >= 30 else "#888")
-    ax2.pie([pop_pred, 100 - pop_pred], colors=[tier_color, "#E8E8E8"],
-            startangle=90, wedgeprops={"edgecolor": "white", "linewidth": 2})
-    ax2.text(0, 0, f"{pop_pred:.0f}", ha="center", va="center",
-             fontsize=28, fontweight="bold", color=tier_color)
-    ax2.set_title(f"Popularity: {tier}", fontweight="bold")
-
-    # Panel 3: Feature importance comparison (from model)
-    ax3 = fig.add_subplot(1, 3, 3)
-    ax3.set_facecolor("#F8F9FA")
-    if SPOT_OK:
-        imp = pd.Series(rf_spot.feature_importances_, index=features_spot).sort_values()
-        ax3.barh(imp.index, imp.values, color=PALETTE["blue"], edgecolor="white")
-        ax3.set_title("Feature Importance\n(model weights)", fontweight="bold")
-        ax3.set_xlabel("Importance")
-    else:
-        ax3.text(0.5, 0.5, "Model not loaded", ha="center")
-
-    plt.tight_layout()
-    tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".png")
-    plt.savefig(tmp.name, dpi=130, bbox_inches="tight", facecolor="#FAFAFA")
-    plt.close()
-    return tmp.name
-
-
-# ════════════════════════════════════════════════════════════
-# AMAZON ANALYSIS FUNCTION
-# ════════════════════════════════════════════════════════════
-
-def analyze_amazon(category, actual_price, discount_pct, rating, review_text, use_gpt):
-    discounted_price = actual_price * (1 - discount_pct / 100)
-    sentiment_score  = analyzer.polarity_scores(review_text)["compound"] if review_text else 0.0
-    sentiment_label  = ("Positive" if sentiment_score >= 0.05
-                        else "Negative" if sentiment_score <= -0.05 else "Neutral")
-
-    if AMZ_OK:
-        X = np.array([[actual_price, discounted_price, discount_pct, rating, sentiment_score]])
-        # Confidence interval via individual tree predictions
-        tree_preds = np.array([t.predict(X)[0] for t in rf_amz.estimators_])
-        log_pred   = tree_preds.mean()
-        log_std    = tree_preds.std()
-        sales_pred = int(np.expm1(log_pred))
-        sales_low  = int(np.expm1(max(0, log_pred - log_std)))
-        sales_high = int(np.expm1(log_pred + log_std))
-    else:
-        sales_pred = int(rating * 1000 * (1 + sentiment_score))
-        sales_low  = int(sales_pred * 0.7)
-        sales_high = int(sales_pred * 1.3)
-
-    score = min(100, int(
-        25 * (rating / 5) +
-        25 * ((sentiment_score + 1) / 2) +
-        25 * min(sales_pred / 50000, 1) +
-        25 * min(discount_pct / 70, 1)
-    ))
-    tier = ("Top Performer" if score >= 75 else "Average" if score >= 45 else "Underperformer")
-
-    # Chart
-    chart_path = make_amazon_chart(rating, sentiment_score, discount_pct, score, sales_pred)
-
-    # Text report
-    report = (
-        f"📦  AMAZON PRODUCT ANALYSIS\n{'═'*42}\n"
-        f"Category:          {category}\n"
-        f"Actual Price:      ₹{actual_price:.0f}\n"
-        f"Discounted Price:  ₹{discounted_price:.0f}  (−{discount_pct}%)\n"
-        f"Rating:            {rating}/5\n"
-        f"{'─'*42}\n"
-        f"SENTIMENT\n"
-        f"  Score:  {sentiment_score:+.3f}   Label: {sentiment_label}\n"
-        f"{'─'*42}\n"
-        f"PREDICTED SALES\n"
-        f"  Est. Reviews: ~{sales_pred:,}\n"
-        f"  90% Range:    {sales_low:,} – {sales_high:,}\n"
-        f"{'─'*42}\n"
-        f"PERFORMANCE SCORE:  {score}/100  ({tier})\n"
-    )
-
-    # GPT or fallback
-    gpt_section = ""
-    if use_gpt:
-        gpt_section = "\n" + get_amazon_gpt_insight(
-            category, actual_price, discounted_price, discount_pct,
-            rating, sentiment_score, sentiment_label, sales_pred, score
-        )
-
-    session_history.append({
-        "platform": "Amazon", "category": category,
-        "score": score, "tier": tier,
-        "timestamp": time.strftime("%H:%M:%S"),
-    })
-
-    return report.strip() + gpt_section, chart_path
-
-
-# ════════════════════════════════════════════════════════════
-# SPOTIFY ANALYSIS FUNCTION
-# ════════════════════════════════════════════════════════════
-
-def analyze_spotify(genre, danceability, energy, loudness, tempo, valence,
-                    acousticness, speechiness, instrumentalness, explicit, use_gpt):
-    exp = int(explicit)
-
-    if SPOT_OK:
-        X = np.array([[danceability, energy, loudness, speechiness, acousticness,
-                       instrumentalness, valence, tempo, exp]])
-        tree_preds = np.array([t.predict(X)[0] for t in rf_spot.estimators_])
-        pop_pred   = float(np.clip(tree_preds.mean(), 0, 100))
-        pop_std    = tree_preds.std()
-    else:
-        pop_pred = float(np.clip(20 + 30*danceability + 15*energy + 0.5*(loudness+20), 0, 100))
-        pop_std  = 5.0
-
-    tier = ("Hit 🔥" if pop_pred >= 70 else "Popular" if pop_pred >= 50
-            else "Mid-tier" if pop_pred >= 30 else "Niche")
-    pop_low  = max(0,   pop_pred - pop_std)
-    pop_high = min(100, pop_pred + pop_std)
-
-    chart_path = make_spotify_chart(
-        danceability, energy, loudness, tempo, valence,
-        acousticness, speechiness, pop_pred, genre
-    )
-
-    report = (
-        f"🎵  SPOTIFY TRACK ANALYSIS\n{'═'*42}\n"
-        f"Genre:          {genre}\n"
-        f"Tempo:          {tempo:.0f} BPM\n"
-        f"Explicit:       {'Yes' if explicit else 'No'}\n"
-        f"{'─'*42}\n"
-        f"AUDIO FEATURES\n"
-        f"  Danceability:   {danceability:.3f}\n"
-        f"  Energy:         {energy:.3f}\n"
-        f"  Loudness:       {loudness:.1f} dB\n"
-        f"  Valence:        {valence:.3f}\n"
-        f"  Acousticness:   {acousticness:.3f}\n"
-        f"  Speechiness:    {speechiness:.3f}\n"
-        f"{'─'*42}\n"
-        f"PREDICTED POPULARITY\n"
-        f"  Score:  {pop_pred:.1f}/100  ({tier})\n"
-        f"  Range:  {pop_low:.1f} – {pop_high:.1f}  (±1 std dev)\n"
-    )
-
-    gpt_section = ""
-    if use_gpt:
-        gpt_section = "\n" + get_spotify_gpt_insight(
-            genre, danceability, energy, loudness, tempo,
-            valence, acousticness, pop_pred, tier
-        )
-
-    session_history.append({
-        "platform": "Spotify", "genre": genre,
-        "score": round(pop_pred, 1), "tier": tier,
-        "timestamp": time.strftime("%H:%M:%S"),
-    })
-
-    return report.strip() + gpt_section, chart_path
-
-
-# ════════════════════════════════════════════════════════════
-# SESSION HISTORY & PIPELINE TRIGGER
-# ════════════════════════════════════════════════════════════
-
-def get_history():
-    if not session_history:
-        return "No analyses run yet this session."
-    lines = [f"{'#':<4} {'Time':<10} {'Platform':<10} {'Detail':<25} {'Score':<8} {'Tier'}"]
-    lines.append("─" * 70)
-    for i, h in enumerate(session_history[-10:], 1):
-        detail = h.get("category", h.get("genre", "—"))
-        lines.append(f"{i:<4} {h['timestamp']:<10} {h['platform']:<10} {detail:<25} {h['score']:<8} {h['tier']}")
-    return "\n".join(lines)
-
-
-def run_pipeline():
-    """Trigger the agentic pipeline from the UI."""
-    if not os.path.exists("agentic_pipeline.py"):
-        return "agentic_pipeline.py not found in current directory."
-    try:
-        result = subprocess.run(
-            ["python3", "agentic_pipeline.py", "--mode", "both", "--quiet"],
-            capture_output=True, text=True, timeout=120
-        )
-        out = result.stdout[-2000:] if len(result.stdout) > 2000 else result.stdout
-        if result.returncode == 0:
-            return f"✓ Pipeline completed successfully.\n\n{out}"
-        else:
-            return f"✗ Pipeline error:\n{result.stderr[:1000]}"
-    except subprocess.TimeoutExpired:
-        return "✗ Pipeline timed out after 120s."
-    except Exception as e:
-        return f"✗ Could not run pipeline: {e}"
-
-
-# ════════════════════════════════════════════════════════════
-# GRADIO INTERFACE
-# ════════════════════════════════════════════════════════════
-
-CUSTOM_CSS = """
-.gr-button-primary { background: #2E86AB !important; border: none !important; }
-.gr-button-secondary { border: 1px solid #2E86AB !important; color: #2E86AB !important; }
-footer { display: none !important; }
-"""
-
-with gr.Blocks(
-    title="AI Performance Analyzer — Amazon × Spotify",
-    theme=gr.themes.Soft(primary_hue="blue", secondary_hue="pink"),
-    css=CUSTOM_CSS,
-) as demo:
-
-    gr.Markdown("""
-    # 🤖 AI Performance Analyzer
-    ### Amazon Products × Spotify Tracks
-    *Real-time ML predictions + GPT-4o-mini insights from a single interface*
-    """)
-
-    with gr.Tabs():
-
-        # ── TAB 1: AMAZON ────────────────────────────────────
-        with gr.TabItem("🛒 Amazon Product"):
-            gr.Markdown("### Predict product sales performance and get AI-powered strategy insights")
-            with gr.Row():
-                with gr.Column(scale=1):
-                    amz_category = gr.Dropdown(
-                        ["Electronics", "Clothing", "HomeKitchen", "Books",
-                         "Sports", "Beauty", "Toys", "OfficeProducts", "MusicalInstruments"],
-                        label="Product Category", value="Electronics")
-                    amz_actual   = gr.Slider(50, 80000, value=999, step=50,
-                                             label="Actual Price (₹)")
-                    amz_discount = gr.Slider(0, 80, value=30, step=1,
-                                             label="Discount %")
-                    amz_rating   = gr.Slider(1.0, 5.0, value=4.2, step=0.1,
-                                             label="Star Rating (/5)")
-                    amz_review   = gr.Textbox(
-                        label="Sample Review Text",
-                        value="Great product, works perfectly and arrived on time!",
-                        lines=3, placeholder="Enter a customer review for sentiment analysis...")
-                    amz_gpt = gr.Checkbox(label="🤖 Generate GPT-4o-mini AI insight", value=True)
-                    amz_btn = gr.Button("Analyze Product", variant="primary", size="lg")
-
-                with gr.Column(scale=2):
-                    amz_output = gr.Textbox(label="Analysis Report", lines=22)
-                    amz_plot   = gr.Image(label="Performance Dashboard", type="filepath")
-
-            amz_btn.click(
-                analyze_amazon,
-                inputs=[amz_category, amz_actual, amz_discount, amz_rating, amz_review, amz_gpt],
-                outputs=[amz_output, amz_plot],
-            )
-
-        # ── TAB 2: SPOTIFY ───────────────────────────────────
-        with gr.TabItem("🎵 Spotify Track"):
-            gr.Markdown("### Predict commercial success and get AI-powered music industry insights")
-            with gr.Row():
-                with gr.Column(scale=1):
-                    sp_genre  = gr.Dropdown(
-                        ["pop", "hip-hop", "rock", "electronic", "jazz",
-                         "r-n-b", "country", "latin", "indie", "classical"],
-                        label="Genre", value="pop")
-                    sp_dance  = gr.Slider(0.0, 1.0, value=0.70, step=0.01, label="Danceability")
-                    sp_energy = gr.Slider(0.0, 1.0, value=0.80, step=0.01, label="Energy")
-                    sp_loud   = gr.Slider(-40, 0, value=-7, step=0.5, label="Loudness (dB)")
-                    sp_tempo  = gr.Slider(60, 200, value=120, step=1, label="Tempo (BPM)")
-                    sp_val    = gr.Slider(0.0, 1.0, value=0.60, step=0.01, label="Valence (mood positivity)")
-                    sp_acou   = gr.Slider(0.0, 1.0, value=0.10, step=0.01, label="Acousticness")
-                    sp_speech = gr.Slider(0.0, 1.0, value=0.05, step=0.01, label="Speechiness")
-                    sp_instr  = gr.Slider(0.0, 1.0, value=0.00, step=0.01, label="Instrumentalness")
-                    sp_exp    = gr.Checkbox(label="Explicit content", value=False)
-                    sp_gpt    = gr.Checkbox(label="🤖 Generate GPT-4o-mini AI insight", value=True)
-                    sp_btn    = gr.Button("Analyze Track", variant="primary", size="lg")
-
-                with gr.Column(scale=2):
-                    sp_output = gr.Textbox(label="Analysis Report", lines=22)
-                    sp_plot   = gr.Image(label="Audio Profile Dashboard", type="filepath")
-
-            sp_btn.click(
-                analyze_spotify,
-                inputs=[sp_genre, sp_dance, sp_energy, sp_loud, sp_tempo,
-                        sp_val, sp_acou, sp_speech, sp_instr, sp_exp, sp_gpt],
-                outputs=[sp_output, sp_plot],
-            )
-
-        # ── TAB 3: SESSION HISTORY ───────────────────────────
-        with gr.TabItem("📋 Session History"):
-            gr.Markdown("### All analyses run this session")
-            hist_output = gr.Textbox(label="Session Log", lines=15)
-            hist_btn = gr.Button("Refresh History", variant="secondary")
-            hist_btn.click(get_history, inputs=[], outputs=[hist_output])
-
-        # ── TAB 4: PIPELINE ──────────────────────────────────
-        with gr.TabItem("⚙️ Agentic Pipeline"):
-            gr.Markdown("""
-            ### Automated End-to-End Pipeline
-            Runs the full agentic pipeline: data ingestion → synthetic generation →
-            model training → inference → report generation. Single-command execution.
-            """)
-            pipe_btn    = gr.Button("▶ Run Agentic Pipeline", variant="primary", size="lg")
-            pipe_output = gr.Textbox(label="Pipeline Output", lines=20)
-            pipe_btn.click(run_pipeline, inputs=[], outputs=[pipe_output])
-
-    gr.Markdown("""
-    ---
-    *Built with Gradio · Models: Random Forest (sklearn) · NLP: VADER · AI: GPT-4o-mini*
-    *Set `OPENAI_API_KEY` as a Hugging Face Secret to enable live GPT insights*
-    """)
-
-if __name__ == "__main__":
-    demo.launch(share=True)