Upload 8 files

DEPLOY.md

@@ -0,0 +1,23 @@
+# Deployment Guide
+
+## Web UI upload path
+
+1. Go to Hugging Face and create a new **Gradio Space**.
+2. Download and unzip this package.
+3. Upload all files from the folder to the Space root.
+4. Wait for the build to install dependencies from `requirements.txt`.
+5. Open the Space. On first load, the notebook runs automatically.
+6. Use **Notebook Runner** if you want to re-run the notebook manually.
+
+## Expected runtime behavior
+
+- The app reads `synthetic_sales_data.csv` and `synthetic_book_reviews.csv`.
+- It runs `pythonanalysis.ipynb` with Papermill.
+- Saved figures appear in the gallery.
+- Saved CSV and JSON outputs appear in the table preview and KPI cards.
+
+## Common fixes
+
+- If build fails, confirm the Space SDK is **Gradio**.
+- If notebook execution fails, check the `Execution Log` tab output.
+- If the AI tab does not use an LLM, set `HF_API_KEY` in Space variables.

README.md

@@ -1,12 +1,51 @@
 ---
-title: Handson5
-emoji: 📊
-colorFrom: gray
-colorTo: blue
+title: ESCP Book Analytics Space
+emoji: 📚
+colorFrom: purple
+colorTo: indigo
 sdk: gradio
-sdk_version: 6.10.0
+sdk_version: 5.23.3
 app_file: app.py
 pinned: false
+python_version: 3.10
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# ESCP Book Analytics Space
+
+This Hugging Face Space runs the included Jupyter notebook automatically and turns the saved outputs into:
+
+- KPI cards
+- Interactive sales charts
+- Sentiment charts
+- Top-seller analysis
+- Table previews
+- A simple AI dashboard for natural-language questions
+
+## Files included
+
+- `app.py` — the Gradio application
+- `pythonanalysis.ipynb` — your uploaded analysis notebook
+- `synthetic_sales_data.csv` — sales dataset
+- `synthetic_book_reviews.csv` — reviews dataset
+- `style.css` — local styling with no background images
+- `requirements.txt` — pinned Python dependencies
+
+## Environment variables
+
+Optional variables for the AI tab:
+
+- `HF_API_KEY`
+- `MODEL_NAME`
+- `HF_PROVIDER`
+- `PAPERMILL_TIMEOUT`
+- `AUTO_RUN_ON_LOAD`
+
+## Notes
+
+The app creates notebook outputs inside:
+
+- `artifacts/py/figures`
+- `artifacts/py/tables`
+- `runs/`
+
+The app also sanitizes the notebook before execution so `!pip install ...` cells are skipped. Dependencies are handled by `requirements.txt`.

app.py

@@ -0,0 +1,736 @@
+# AI-Assisted Code — Academic Integrity Notice
+# Generated with The App Builder. ESCP coursework.
+# Student must be able to explain all code when asked.
+
+import json
+import os
+import re
+import time
+import traceback
+from pathlib import Path
+from typing import Any, Dict, List, Tuple
+
+import gradio as gr
+import nbformat
+import pandas as pd
+import papermill as pm
+import plotly.graph_objects as go
+
+# Optional LLM support via Hugging Face Inference API
+try:
+    from huggingface_hub import InferenceClient
+except Exception:
+    InferenceClient = None
+
+
+# =========================================================
+# CONFIG
+# =========================================================
+
+BASE_DIR = Path(__file__).resolve().parent
+NOTEBOOK_NAME = os.environ.get("NB2", "pythonanalysis.ipynb").strip()
+
+RUNS_DIR = BASE_DIR / "runs"
+ART_DIR = BASE_DIR / "artifacts"
+PY_FIG_DIR = ART_DIR / "py" / "figures"
+PY_TAB_DIR = ART_DIR / "py" / "tables"
+TMP_DIR = BASE_DIR / "tmp"
+
+PAPERMILL_TIMEOUT = int(os.environ.get("PAPERMILL_TIMEOUT", "1800"))
+MAX_PREVIEW_ROWS = int(os.environ.get("MAX_FILE_PREVIEW_ROWS", "50"))
+AUTO_RUN_ON_LOAD = os.environ.get("AUTO_RUN_ON_LOAD", "true").lower() == "true"
+
+HF_API_KEY = os.environ.get("HF_API_KEY", "").strip()
+MODEL_NAME = os.environ.get("MODEL_NAME", "meta-llama/Llama-3.1-8B-Instruct").strip()
+HF_PROVIDER = os.environ.get("HF_PROVIDER", "hf-inference").strip()
+
+LLM_ENABLED = bool(HF_API_KEY) and InferenceClient is not None
+llm_client = (
+    InferenceClient(provider=HF_PROVIDER, api_key=HF_API_KEY)
+    if LLM_ENABLED
+    else None
+)
+
+
+# =========================================================
+# HELPERS
+# =========================================================
+
+def ensure_dirs() -> None:
+    """Create all required folders."""
+    for folder in [RUNS_DIR, ART_DIR, PY_FIG_DIR, PY_TAB_DIR, TMP_DIR]:
+        folder.mkdir(parents=True, exist_ok=True)
+
+
+def stamp() -> str:
+    """Generate a timestamp for run files."""
+    return time.strftime("%Y%m%d-%H%M%S")
+
+
+def _ls(dir_path: Path, exts: Tuple[str, ...]) -> List[str]:
+    """List files in a folder filtered by extension."""
+    if not dir_path.is_dir():
+        return []
+    return sorted(
+        p.name for p in dir_path.iterdir()
+        if p.is_file() and p.suffix.lower() in exts
+    )
+
+
+def _read_csv(path: Path) -> pd.DataFrame:
+    """Read a CSV safely for preview."""
+    return pd.read_csv(path, nrows=MAX_PREVIEW_ROWS)
+
+
+def _read_json(path: Path) -> Any:
+    """Read JSON safely."""
+    with path.open(encoding="utf-8") as file:
+        return json.load(file)
+
+
+def artifacts_index() -> Dict[str, Any]:
+    """Return the currently available artifact files."""
+    return {
+        "python": {
+            "figures": _ls(PY_FIG_DIR, (".png", ".jpg", ".jpeg")),
+            "tables": _ls(PY_TAB_DIR, (".csv", ".json")),
+        }
+    }
+
+
+def has_artifacts() -> bool:
+    """Check whether the notebook already produced outputs."""
+    idx = artifacts_index()
+    return bool(idx["python"]["figures"] or idx["python"]["tables"])
+
+
+def sanitize_notebook(source_path: Path) -> Path:
+    """Create a runtime copy of the notebook without !pip install cells."""
+    notebook = nbformat.read(source_path, as_version=4)
+    cleaned_cells = []
+
+    for cell in notebook.cells:
+        if cell.cell_type != "code":
+            cleaned_cells.append(cell)
+            continue
+
+        source = cell.source.strip()
+        if source.startswith("!pip install"):
+            continue
+
+        lines = [
+            line for line in cell.source.splitlines()
+            if not line.strip().startswith("!pip install")
+        ]
+        cell.source = "\n".join(lines).strip()
+        cleaned_cells.append(cell)
+
+    notebook.cells = cleaned_cells
+    cleaned_path = TMP_DIR / f"cleaned_{source_path.name}"
+    nbformat.write(notebook, cleaned_path)
+    return cleaned_path
+
+
+def _load_table_safe(path: Path) -> pd.DataFrame:
+    """Load CSV or JSON table for display."""
+    try:
+        if path.suffix.lower() == ".json":
+            obj = _read_json(path)
+            if isinstance(obj, dict):
+                return pd.DataFrame([obj])
+            return pd.DataFrame(obj)
+        return _read_csv(path)
+    except Exception as exc:
+        return pd.DataFrame([{"error": str(exc)}])
+
+
+# =========================================================
+# NOTEBOOK RUNNER
+# =========================================================
+
+def run_notebook() -> str:
+    """Execute the uploaded notebook with Papermill."""
+    ensure_dirs()
+    notebook_path = BASE_DIR / NOTEBOOK_NAME
+
+    if not notebook_path.exists():
+        return f"ERROR: {NOTEBOOK_NAME} not found in the Space root folder."
+
+    cleaned_nb = sanitize_notebook(notebook_path)
+    output_nb = RUNS_DIR / f"run_{stamp()}_{NOTEBOOK_NAME}"
+
+    pm.execute_notebook(
+        input_path=str(cleaned_nb),
+        output_path=str(output_nb),
+        cwd=str(BASE_DIR),
+        log_output=True,
+        progress_bar=False,
+        request_save_on_cell_execute=True,
+        execution_timeout=PAPERMILL_TIMEOUT,
+    )
+    return f"Executed notebook: {NOTEBOOK_NAME}"
+
+
+def run_pipeline() -> str:
+    """Run the full notebook and summarize generated outputs."""
+    try:
+        log = run_notebook()
+        idx = artifacts_index()
+        figures = idx["python"]["figures"]
+        tables = idx["python"]["tables"]
+
+        lines = [
+            "✅ Notebook execution completed.",
+            log,
+            "",
+            f"Figures: {', '.join(figures) or '(none)'}",
+            f"Tables: {', '.join(tables) or '(none)'}",
+        ]
+        return "\n".join(lines)
+    except Exception as exc:
+        return f"❌ Notebook execution failed: {exc}\n\n{traceback.format_exc()[-3000:]}"
+
+
+def maybe_autorun() -> Tuple[str, str, go.Figure, go.Figure, go.Figure, List[Tuple[str, str]], gr.Dropdown, pd.DataFrame]:
+    """Auto-run once when the app loads if no artifacts exist yet."""
+    ensure_dirs()
+    if AUTO_RUN_ON_LOAD and not has_artifacts():
+        log = run_pipeline()
+    else:
+        log = "Ready. Existing artifacts found, so auto-run was skipped."
+
+    kpi_html = render_kpi_cards()
+    sales_chart = build_sales_chart()
+    sentiment_chart = build_sentiment_chart()
+    top_chart = build_top_sellers_chart()
+    figures, dropdown_update, default_df = refresh_gallery()
+    return log, kpi_html, sales_chart, sentiment_chart, top_chart, figures, dropdown_update, default_df
+
+
+# =========================================================
+# GALLERY + KPI LOADERS
+# =========================================================
+
+def _load_all_figures() -> List[Tuple[str, str]]:
+    """Return all saved figures for the Gradio gallery."""
+    items = []
+    for path in sorted(PY_FIG_DIR.glob("*.png")):
+        items.append((str(path), path.stem.replace("_", " ").title()))
+    for path in sorted(PY_FIG_DIR.glob("*.jpg")):
+        items.append((str(path), path.stem.replace("_", " ").title()))
+    return items
+
+
+def refresh_gallery():
+    """Refresh gallery content and the table selector."""
+    figures = _load_all_figures()
+    idx = artifacts_index()
+    table_choices = list(idx["python"]["tables"])
+
+    default_df = pd.DataFrame([{"hint": "Run the notebook to generate tables."}])
+    if table_choices:
+        default_df = _load_table_safe(PY_TAB_DIR / table_choices[0])
+
+    return (
+        figures,
+        gr.update(
+            choices=table_choices,
+            value=table_choices[0] if table_choices else None,
+        ),
+        default_df,
+    )
+
+
+def on_table_select(choice: str) -> pd.DataFrame:
+    """Load a selected table into the preview grid."""
+    if not choice:
+        return pd.DataFrame([{"hint": "Select a table above."}])
+
+    path = PY_TAB_DIR / choice
+    if not path.exists():
+        return pd.DataFrame([{"error": f"File not found: {choice}"}])
+
+    return _load_table_safe(path)
+
+
+def load_kpis() -> Dict[str, Any]:
+    """Load KPI JSON if the notebook generated one."""
+    candidates = [
+        PY_TAB_DIR / "kpis.json",
+        PY_FIG_DIR / "kpis.json",
+    ]
+    for candidate in candidates:
+        if candidate.exists():
+            try:
+                return _read_json(candidate)
+            except Exception:
+                pass
+    return {}
+
+
+# =========================================================
+# AI DASHBOARD
+# =========================================================
+
+DASHBOARD_SYSTEM = """You are an AI dashboard assistant for a book analytics app.
+The user asks questions about notebook outputs. You have access to precomputed artifacts.
+
+AVAILABLE ARTIFACTS:
+{artifacts_json}
+
+KPI SUMMARY:
+{kpis_json}
+
+At the end of every answer, output a fenced JSON block:
+{{"show": "figure"|"table"|"none", "scope": "python", "filename": "..."}}
+
+Rules:
+- Use figure for sales trends, forecast plots, or sentiment plots.
+- Use table for top sellers, pricing decisions, or dashboard tables.
+- Use none if nothing relevant exists.
+- Keep the natural-language answer to 2-4 sentences.
+"""
+
+JSON_BLOCK_RE = re.compile(r"```json\s*(\{.*?\})\s*```", re.DOTALL)
+FALLBACK_JSON_RE = re.compile(r"\{[^{}]*\"show\"[^{}]*\}", re.DOTALL)
+
+
+def _parse_display_directive(text: str) -> Dict[str, str]:
+    """Extract the JSON display instruction from the model response."""
+    match = JSON_BLOCK_RE.search(text)
+    if match:
+        try:
+            return json.loads(match.group(1))
+        except json.JSONDecodeError:
+            pass
+
+    match = FALLBACK_JSON_RE.search(text)
+    if match:
+        try:
+            return json.loads(match.group(0))
+        except json.JSONDecodeError:
+            pass
+
+    return {"show": "none"}
+
+
+def _clean_response(text: str) -> str:
+    """Remove the JSON display block from the shown answer."""
+    return JSON_BLOCK_RE.sub("", text).strip()
+
+
+def _keyword_fallback(msg: str, idx: Dict[str, Any], kpis: Dict[str, Any]) -> Tuple[str, Dict[str, str]]:
+    """Fallback routing when no LLM key is configured."""
+    lowered = msg.lower()
+
+    if not idx["python"]["figures"] and not idx["python"]["tables"]:
+        return (
+            "No notebook artifacts exist yet. Run the notebook first, then ask again.",
+            {"show": "none"},
+        )
+
+    summary = ""
+    if kpis:
+        total_units = kpis.get("total_units_sold", 0)
+        summary = (
+            f"Quick summary: {kpis.get('n_titles', '?')} titles across "
+            f"{kpis.get('n_months', '?')} months with {total_units:,.0f} units sold."
+        )
+
+    if any(word in lowered for word in ["trend", "sales", "forecast", "arima", "predict"]):
+        return (
+            f"Here is the sales view. {summary}",
+            {"show": "figure", "scope": "python", "filename": "df_dashboard.csv"},
+        )
+
+    if any(word in lowered for word in ["sentiment", "positive", "negative", "review"]):
+        return (
+            f"Here is the sentiment view. {summary}",
+            {"show": "figure", "scope": "python", "filename": "sentiment_counts_sampled.csv"},
+        )
+
+    if any(word in lowered for word in ["top", "best", "popular", "rank"]):
+        return (
+            f"Here are the top-selling titles. {summary}",
+            {"show": "table", "scope": "python", "filename": "top_titles_by_units_sold.csv"},
+        )
+
+    if any(word in lowered for word in ["price", "pricing", "decision"]):
+        return (
+            f"Here are the pricing decisions. {summary}",
+            {"show": "table", "scope": "python", "filename": "pricing_decisions.csv"},
+        )
+
+    if any(word in lowered for word in ["overview", "dashboard", "summary", "kpi"]):
+        return (
+            f"Here is the notebook dashboard overview. {summary}",
+            {"show": "table", "scope": "python", "filename": "df_dashboard.csv"},
+        )
+
+    return (
+        "I can answer questions about sales trends, sentiment, forecasts, pricing decisions, and top sellers.",
+        {"show": "none"},
+    )
+
+
+def ai_chat(user_msg: str, history: List[Dict[str, str]]):
+    """Drive the AI dashboard using either an LLM or keyword fallback."""
+    if not user_msg or not user_msg.strip():
+        return history, "", None, None
+
+    idx = artifacts_index()
+    kpis = load_kpis()
+
+    if not LLM_ENABLED:
+        reply, directive = _keyword_fallback(user_msg, idx, kpis)
+    else:
+        system_prompt = DASHBOARD_SYSTEM.format(
+            artifacts_json=json.dumps(idx, indent=2),
+            kpis_json=json.dumps(kpis, indent=2) if kpis else "(no KPIs yet)",
+        )
+        messages = [{"role": "system", "content": system_prompt}]
+        messages.extend((history or [])[-6:])
+        messages.append({"role": "user", "content": user_msg})
+
+        try:
+            response = llm_client.chat_completion(
+                model=MODEL_NAME,
+                messages=messages,
+                temperature=0.3,
+                max_tokens=500,
+                stream=False,
+            )
+            raw = (
+                response["choices"][0]["message"]["content"]
+                if isinstance(response, dict)
+                else response.choices[0].message.content
+            )
+            directive = _parse_display_directive(raw)
+            reply = _clean_response(raw)
+        except Exception as exc:
+            reply, directive = _keyword_fallback(user_msg, idx, kpis)
+            reply = f"LLM error: {exc}\n\n{reply}"
+
+    chart_out = None
+    table_out = None
+    filename = directive.get("filename", "")
+    show = directive.get("show", "none")
+
+    if show == "figure":
+        if "sentiment" in filename:
+            chart_out = build_sentiment_chart()
+        elif "top_titles" in filename:
+            chart_out = build_top_sellers_chart()
+        else:
+            chart_out = build_sales_chart()
+
+    if show == "table" and filename:
+        file_path = PY_TAB_DIR / filename
+        if file_path.exists():
+            table_out = _load_table_safe(file_path)
+        else:
+            table_out = pd.DataFrame([{"error": f"Missing table: {filename}"}])
+
+    new_history = (history or []) + [
+        {"role": "user", "content": user_msg},
+        {"role": "assistant", "content": reply},
+    ]
+    return new_history, "", chart_out, table_out
+
+
+# =========================================================
+# KPI CARDS
+# =========================================================
+
+def render_kpi_cards() -> str:
+    """Render KPI cards as HTML."""
+    kpis = load_kpis()
+    if not kpis:
+        return """
+        <div class="card-grid">
+          <div class="kpi-card">
+            <div class="kpi-icon">📊</div>
+            <div class="kpi-label">No data yet</div>
+            <div class="kpi-value">Run the notebook first</div>
+          </div>
+        </div>
+        """
+
+    def format_value(value: Any) -> str:
+        if isinstance(value, (int, float)) and value > 100:
+            return f"{value:,.0f}"
+        return str(value)
+
+    html = ['<div class="card-grid">']
+    for key, value in kpis.items():
+        label = key.replace("_", " ").title()
+        html.append(
+            f"""
+            <div class="kpi-card">
+              <div class="kpi-icon">📈</div>
+              <div class="kpi-label">{label}</div>
+              <div class="kpi-value">{format_value(value)}</div>
+            </div>
+            """
+        )
+    html.append("</div>")
+    return "".join(html)
+
+
+# =========================================================
+# CHART BUILDERS
+# =========================================================
+
+CHART_PALETTE = [
+    "#7c5cbf", "#2ec4a0", "#e8537a", "#e8a230", "#5e8fef",
+    "#c45ea8", "#3dbacc", "#a0522d", "#6aaa3a", "#d46060",
+]
+
+
+def _styled_layout(**kwargs) -> Dict[str, Any]:
+    """Apply a consistent Plotly style."""
+    defaults = dict(
+        template="plotly_white",
+        paper_bgcolor="rgba(255,255,255,0.98)",
+        plot_bgcolor="rgba(255,255,255,0.98)",
+        font=dict(family="system-ui, sans-serif", color="#2d1f4e", size=12),
+        margin=dict(l=60, r=20, t=70, b=60),
+        legend=dict(
+            orientation="h",
+            yanchor="bottom",
+            y=1.02,
+            xanchor="right",
+            x=1,
+        ),
+        title=dict(font=dict(size=16, color="#4b2d8a")),
+    )
+    defaults.update(kwargs)
+    return defaults
+
+
+def _empty_chart(title: str) -> go.Figure:
+    """Return a placeholder chart."""
+    fig = go.Figure()
+    fig.update_layout(
+        title=title,
+        height=420,
+        template="plotly_white",
+        annotations=[
+            dict(
+                text="Run the notebook to generate this chart",
+                x=0.5,
+                y=0.5,
+                xref="paper",
+                yref="paper",
+                showarrow=False,
+                font=dict(size=14),
+            )
+        ],
+    )
+    return fig
+
+
+def build_sales_chart() -> go.Figure:
+    """Build the monthly sales chart from df_dashboard.csv."""
+    path = PY_TAB_DIR / "df_dashboard.csv"
+    if not path.exists():
+        return _empty_chart("Monthly Overview")
+
+    df = pd.read_csv(path)
+    date_col = next((c for c in df.columns if "month" in c.lower() or "date" in c.lower()), None)
+    value_cols = [
+        c for c in df.columns
+        if c != date_col and pd.api.types.is_numeric_dtype(df[c])
+    ]
+
+    if not date_col or not value_cols:
+        return _empty_chart("Monthly Overview")
+
+    df[date_col] = pd.to_datetime(df[date_col], errors="coerce")
+    fig = go.Figure()
+
+    for idx, col in enumerate(value_cols):
+        fig.add_trace(
+            go.Scatter(
+                x=df[date_col],
+                y=df[col],
+                mode="lines+markers",
+                name=col.replace("_", " ").title(),
+                line=dict(color=CHART_PALETTE[idx % len(CHART_PALETTE)], width=2),
+                marker=dict(size=5),
+            )
+        )
+
+    fig.update_layout(**_styled_layout(height=450, hovermode="x unified", title=dict(text="Monthly Overview")))
+    return fig
+
+
+def build_sentiment_chart() -> go.Figure:
+    """Build the sentiment chart from sentiment_counts_sampled.csv."""
+    path = PY_TAB_DIR / "sentiment_counts_sampled.csv"
+    if not path.exists():
+        return _empty_chart("Sentiment Distribution")
+
+    df = pd.read_csv(path)
+    title_col = df.columns[0]
+    sentiment_cols = [c for c in ["negative", "neutral", "positive"] if c in df.columns]
+    if not sentiment_cols:
+        return _empty_chart("Sentiment Distribution")
+
+    fig = go.Figure()
+    colors = {"negative": "#e8537a", "neutral": "#5e8fef", "positive": "#2ec4a0"}
+
+    for col in sentiment_cols:
+        fig.add_trace(
+            go.Bar(
+                y=df[title_col],
+                x=df[col],
+                orientation="h",
+                name=col.title(),
+                marker_color=colors[col],
+            )
+        )
+
+    fig.update_layout(
+        **_styled_layout(
+            height=max(400, len(df) * 28),
+            barmode="stack",
+            title=dict(text="Sentiment Distribution by Book"),
+        )
+    )
+    fig.update_yaxes(autorange="reversed")
+    return fig
+
+
+def build_top_sellers_chart() -> go.Figure:
+    """Build the top sellers chart from top_titles_by_units_sold.csv."""
+    path = PY_TAB_DIR / "top_titles_by_units_sold.csv"
+    if not path.exists():
+        return _empty_chart("Top Sellers")
+
+    df = pd.read_csv(path).head(15)
+    title_col = next((c for c in df.columns if "title" in c.lower()), df.columns[0])
+    value_col = next((c for c in df.columns if "unit" in c.lower() or "sold" in c.lower()), df.columns[-1])
+
+    fig = go.Figure(
+        go.Bar(
+            y=df[title_col],
+            x=df[value_col],
+            orientation="h",
+            marker=dict(color=df[value_col], colorscale=[[0, "#c5b4f0"], [1, "#7c5cbf"]]),
+        )
+    )
+    fig.update_layout(**_styled_layout(height=max(400, len(df) * 30), showlegend=False, title=dict(text="Top Selling Titles")))
+    fig.update_yaxes(autorange="reversed")
+    return fig
+
+
+def refresh_dashboard():
+    """Refresh all dashboard widgets."""
+    return render_kpi_cards(), build_sales_chart(), build_sentiment_chart(), build_top_sellers_chart()
+
+
+# =========================================================
+# UI
+# =========================================================
+
+def load_css() -> str:
+    """Read the local CSS file if present."""
+    css_path = BASE_DIR / "style.css"
+    return css_path.read_text(encoding="utf-8") if css_path.exists() else ""
+
+
+ensure_dirs()
+
+with gr.Blocks(title="ESCP Book Analytics Space", css=load_css(), theme=gr.themes.Soft()) as demo:
+    gr.Markdown(
+        """
+        # ESCP Book Analytics Space
+        This Space automatically runs your uploaded notebook and turns the saved outputs
+        into an interactive dashboard for sales, sentiment, top sellers, and pricing decisions.
+        """,
+        elem_id="app_title",
+    )
+
+    with gr.Tab("Notebook Runner"):
+        gr.Markdown("Run the notebook manually whenever you want to refresh the outputs.")
+        run_btn = gr.Button("Run Notebook", variant="primary")
+        run_log = gr.Textbox(label="Execution Log", lines=18, max_lines=30, interactive=False)
+        run_btn.click(run_pipeline, outputs=run_log)
+
+    with gr.Tab("Dashboard"):
+        kpi_html = gr.HTML(value=render_kpi_cards())
+        refresh_btn = gr.Button("Refresh Dashboard", variant="primary")
+
+        gr.Markdown("### Interactive Charts")
+        chart_sales = gr.Plot(label="Monthly Overview")
+        chart_sentiment = gr.Plot(label="Sentiment Distribution")
+        chart_top = gr.Plot(label="Top Sellers")
+
+        gr.Markdown("### Static Figures")
+        gallery = gr.Gallery(label="Generated Notebook Figures", columns=2, height=420, object_fit="contain")
+
+        gr.Markdown("### Data Tables")
+        table_dropdown = gr.Dropdown(label="Select a table", choices=[], interactive=True)
+        table_display = gr.Dataframe(label="Table Preview", interactive=False)
+
+        def _on_refresh():
+            kpi, c1, c2, c3 = refresh_dashboard()
+            figs, dd, df = refresh_gallery()
+            return kpi, c1, c2, c3, figs, dd, df
+
+        refresh_btn.click(
+            _on_refresh,
+            outputs=[kpi_html, chart_sales, chart_sentiment, chart_top, gallery, table_dropdown, table_display],
+        )
+        table_dropdown.change(on_table_select, inputs=table_dropdown, outputs=table_display)
+
+    with gr.Tab("AI Dashboard"):
+        status_text = (
+            "LLM mode is active." if LLM_ENABLED
+            else "Keyword matching mode is active. Set HF_API_KEY later if you want natural-language routing."
+        )
+        gr.Markdown(
+            f"""
+            ### Ask questions about your notebook outputs
+            {status_text}
+            """
+        )
+
+        with gr.Row(equal_height=True):
+            with gr.Column(scale=1):
+                chatbot = gr.Chatbot(label="Conversation", height=380, type="messages")
+                user_input = gr.Textbox(
+                    label="Ask about your data",
+                    placeholder="Show me the sales trends / Which titles sell the most? / What is the sentiment distribution?",
+                    lines=1,
+                )
+                gr.Examples(
+                    examples=[
+                        "Show me the sales trends",
+                        "What does the sentiment look like?",
+                        "Which titles sell the most?",
+                        "Show the pricing decisions",
+                        "Give me a dashboard overview",
+                    ],
+                    inputs=user_input,
+                )
+
+            with gr.Column(scale=1):
+                ai_figure = gr.Plot(label="Interactive Chart")
+                ai_table = gr.Dataframe(label="Data Table", interactive=False)
+
+        user_input.submit(
+            ai_chat,
+            inputs=[user_input, chatbot],
+            outputs=[chatbot, user_input, ai_figure, ai_table],
+        )
+
+    demo.load(
+        maybe_autorun,
+        outputs=[run_log, kpi_html, chart_sales, chart_sentiment, chart_top, gallery, table_dropdown, table_display],
+    )
+
+
+if __name__ == "__main__":
+    demo.launch()

requirements.txt

@@ -0,0 +1,17 @@
+gradio==5.23.3
+pandas==2.2.3
+papermill==2.6.0
+plotly==6.0.1
+nbformat==5.10.4
+matplotlib==3.10.1
+seaborn==0.13.2
+numpy==2.2.4
+vaderSentiment==3.3.2
+statsmodels==0.14.4
+textblob==0.19.0
+transformers==4.49.0
+huggingface_hub==0.29.3
+requests==2.32.3
+faker==37.1.0
+jupyter==1.1.1
+ipykernel==6.29.5

style.css

@@ -0,0 +1,70 @@
+
+:root {
+  --bg: linear-gradient(135deg, #f7f3ff 0%, #eef4ff 100%);
+  --card: rgba(255, 255, 255, 0.86);
+  --border: rgba(124, 92, 191, 0.18);
+  --text: #2d1f4e;
+  --muted: #6f60a8;
+  --accent: #7c5cbf;
+}
+
+body, .gradio-container {
+  background: var(--bg) !important;
+  color: var(--text) !important;
+  font-family: Inter, system-ui, sans-serif !important;
+}
+
+#app_title {
+  background: var(--card);
+  border: 1px solid var(--border);
+  border-radius: 22px;
+  padding: 10px 18px;
+  box-shadow: 0 10px 30px rgba(124, 92, 191, 0.08);
+}
+
+.card-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(150px, 1fr));
+  gap: 14px;
+  margin: 10px 0 22px 0;
+}
+
+.kpi-card {
+  background: var(--card);
+  border: 1px solid var(--border);
+  border-radius: 20px;
+  padding: 18px 14px;
+  text-align: center;
+  box-shadow: 0 8px 20px rgba(124, 92, 191, 0.08);
+  backdrop-filter: blur(12px);
+}
+
+.kpi-icon {
+  font-size: 26px;
+  margin-bottom: 8px;
+}
+
+.kpi-label {
+  color: var(--muted);
+  font-size: 11px;
+  text-transform: uppercase;
+  letter-spacing: 1.2px;
+  font-weight: 700;
+  margin-bottom: 6px;
+}
+
+.kpi-value {
+  color: var(--text);
+  font-size: 18px;
+  font-weight: 800;
+}
+
+button.primary, button.lg.primary {
+  background: linear-gradient(135deg, #7c5cbf 0%, #5e8fef 100%) !important;
+  border: none !important;
+}
+
+.gradio-container .tabitem {
+  background: rgba(255, 255, 255, 0.72);
+  border-radius: 16px;
+}