Upload 6 files

README.md

@@ -1,11 +1,47 @@
 ---
-title: SE21 App Template
-emoji: 📊
-colorFrom: blue
-colorTo: purple
-sdk: docker
+title: Interactive Notebook Runner
+emoji: 📓
+colorFrom: indigo
+colorTo: blue
+sdk: gradio
+sdk_version: 4.44.0
+app_file: app.py
 pinned: false
-short_description: AI-enhanced analytics dashboard template for SE21 students
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Interactive Notebook Runner
+
+This Space lets a user:
+- upload a Jupyter notebook
+- upload two CSV datasets
+- preview the uploaded datasets
+- run the notebook in the browser
+- download the executed notebook and a ZIP of outputs
+
+## Files to upload to the Space root
+- `app.py`
+- `requirements.txt`
+- `README.md`
+
+## Optional bundled defaults
+If you want the app to work even with no uploads, also keep:
+- `analysis_notebook.ipynb`
+- `synthetic_book_reviews.csv`
+- `synthetic_sales_data.csv`
+
+## Important notebook rule
+The app copies the two selected CSV files into the runtime folder with these names:
+- `synthetic_book_reviews.csv`
+- `synthetic_sales_data.csv`
+
+So the notebook should read those filenames during execution.
+
+## Why the app is interactive
+The UI has:
+- file upload components
+- a preview button
+- a run button
+- output tables
+- downloadable files
+
+That means the user is not just reading a static page; they can actively choose files and trigger execution.

app.py

@@ -1,758 +1,299 @@
-import os
+# AI-Assisted Code — Academic Integrity Notice
+# Generated with The App Builder. ESCP coursework.
+# Student must be able to explain all code when asked.
+
+"""Interactive Hugging Face Space to execute a Jupyter notebook on uploaded CSV files."""
+
+import io
 import re
 import json
-import time
-import traceback
+import shutil
+import zipfile
+import tempfile
 from pathlib import Path
-from typing import Dict, Any, List, Tuple
 
-import pandas as pd
 import gradio as gr
-import papermill as pm
-import plotly.graph_objects as go
-
-# Optional LLM (HuggingFace Inference API)
-try:
-    from huggingface_hub import InferenceClient
-except Exception:
-    InferenceClient = None
-
-# =========================================================
-# CONFIG
-# =========================================================
-
-BASE_DIR = Path(__file__).resolve().parent
-
-NB1 = os.environ.get("NB1", "datacreation.ipynb").strip()
-NB2 = 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"
-
-PAPERMILL_TIMEOUT = int(os.environ.get("PAPERMILL_TIMEOUT", "1800"))
-MAX_PREVIEW_ROWS = int(os.environ.get("MAX_FILE_PREVIEW_ROWS", "50"))
-MAX_LOG_CHARS = int(os.environ.get("MAX_LOG_CHARS", "8000"))
-
-HF_API_KEY = os.environ.get("HF_API_KEY", "").strip()
-MODEL_NAME = os.environ.get("MODEL_NAME", "deepseek-ai/DeepSeek-R1").strip()
-HF_PROVIDER = os.environ.get("HF_PROVIDER", "novita").strip()
-N8N_WEBHOOK_URL = os.environ.get("N8N_WEBHOOK_URL", "").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():
-    for p in [RUNS_DIR, ART_DIR, PY_FIG_DIR, PY_TAB_DIR]:
-        p.mkdir(parents=True, exist_ok=True)
-
-def stamp():
-    return time.strftime("%Y%m%d-%H%M%S")
-
-def tail(text: str, n: int = MAX_LOG_CHARS) -> str:
-    return (text or "")[-n:]
-
-def _ls(dir_path: Path, exts: Tuple[str, ...]) -> List[str]:
-    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:
-    return pd.read_csv(path, nrows=MAX_PREVIEW_ROWS)
-
-def _read_json(path: Path):
-    with path.open(encoding="utf-8") as f:
-        return json.load(f)
-
-def artifacts_index() -> Dict[str, Any]:
-    return {
-        "python": {
-            "figures": _ls(PY_FIG_DIR, (".png", ".jpg", ".jpeg")),
-            "tables": _ls(PY_TAB_DIR, (".csv", ".json")),
-        },
-    }
-
-# =========================================================
-# PIPELINE RUNNERS
-# =========================================================
-
-def run_notebook(nb_name: str) -> str:
-    ensure_dirs()
-    nb_in = BASE_DIR / nb_name
-    if not nb_in.exists():
-        return f"ERROR: {nb_name} not found."
-    nb_out = RUNS_DIR / f"run_{stamp()}_{nb_name}"
-    pm.execute_notebook(
-        input_path=str(nb_in),
-        output_path=str(nb_out),
-        cwd=str(BASE_DIR),
-        log_output=True,
-        progress_bar=False,
-        request_save_on_cell_execute=True,
-        execution_timeout=PAPERMILL_TIMEOUT,
-    )
-    return f"Executed {nb_name}"
-
-
-def run_datacreation() -> str:
-    try:
-        log = run_notebook(NB1)
-        csvs = [f.name for f in BASE_DIR.glob("*.csv")]
-        return f"OK  {log}\n\nCSVs now in /app:\n" + "\n".join(f"  - {c}" for c in sorted(csvs))
-    except Exception as e:
-        return f"FAILED  {e}\n\n{traceback.format_exc()[-2000:]}"
-
-
-def run_pythonanalysis() -> str:
-    try:
-        log = run_notebook(NB2)
-        idx = artifacts_index()
-        figs = idx["python"]["figures"]
-        tabs = idx["python"]["tables"]
-        return (
-            f"OK  {log}\n\n"
-            f"Figures: {', '.join(figs) or '(none)'}\n"
-            f"Tables:  {', '.join(tabs) or '(none)'}"
-        )
-    except Exception as e:
-        return f"FAILED  {e}\n\n{traceback.format_exc()[-2000:]}"
-
-
-def run_full_pipeline() -> str:
-    logs = []
-    logs.append("=" * 50)
-    logs.append("STEP 1/2: Data Creation (web scraping + synthetic data)")
-    logs.append("=" * 50)
-    logs.append(run_datacreation())
-    logs.append("")
-    logs.append("=" * 50)
-    logs.append("STEP 2/2: Python Analysis (sentiment, ARIMA, dashboard)")
-    logs.append("=" * 50)
-    logs.append(run_pythonanalysis())
-    return "\n".join(logs)
-
-
-# =========================================================
-# GALLERY LOADERS
-# =========================================================
-
-def _load_all_figures() -> List[Tuple[str, str]]:
-    """Return list of (filepath, caption) for Gallery."""
-    items = []
-    for p in sorted(PY_FIG_DIR.glob("*.png")):
-        items.append((str(p), p.stem.replace('_', ' ').title()))
-    return items
-
-
-def _load_table_safe(path: Path) -> pd.DataFrame:
+import nbformat
+import pandas as pd
+from nbclient import NotebookClient
+from nbclient.exceptions import CellExecutionError
+
+
+APP_DIR = Path(__file__).resolve().parent
+DEFAULT_NOTEBOOK = APP_DIR / "analysis_notebook.ipynb"
+DEFAULT_CSVS = [
+    APP_DIR / "synthetic_book_reviews.csv",
+    APP_DIR / "synthetic_sales_data.csv",
+]
+EXPECTED_DATASET_NAMES = [
+    "synthetic_book_reviews.csv",
+    "synthetic_sales_data.csv",
+]
+
+
+def _display_name(file_obj):
+    """Return a readable filename from a Gradio upload object."""
+    if file_obj is None:
+        return ""
+    if isinstance(file_obj, str):
+        return Path(file_obj).name
+    name = getattr(file_obj, "name", "")
+    return Path(name).name if name else ""
+
+
+def _resolve_uploaded_path(file_obj):
+    """Convert Gradio file input into a local Path."""
+    if file_obj is None:
+        return None
+    if isinstance(file_obj, str):
+        return Path(file_obj)
+    file_name = getattr(file_obj, "name", None)
+    return Path(file_name) if file_name else None
+
+
+def _preview_csv(file_obj):
+    """Load a small preview for the UI."""
+    file_path = _resolve_uploaded_path(file_obj)
+    if file_path is None:
+        return pd.DataFrame({"Info": ["No file uploaded yet."]})
     try:
-        if path.suffix == ".json":
-            obj = _read_json(path)
-            if isinstance(obj, dict):
-                return pd.DataFrame([obj])
-            return pd.DataFrame(obj)
-        return _read_csv(path)
-    except Exception as e:
-        return pd.DataFrame([{"error": str(e)}])
-
-
-def refresh_gallery():
-    """Called when user clicks Refresh on Gallery tab."""
-    figures = _load_all_figures()
-    idx = artifacts_index()
-
-    table_choices = list(idx["python"]["tables"])
-
-    default_df = pd.DataFrame()
-    if table_choices:
-        default_df = _load_table_safe(PY_TAB_DIR / table_choices[0])
-
-    return (
-        figures if figures else [],
-        gr.update(choices=table_choices, value=table_choices[0] if table_choices else None),
-        default_df,
+        preview_df = pd.read_csv(file_path).head(10)
+        return preview_df
+    except Exception as error:
+        return pd.DataFrame({"Error": [f"Could not preview {file_path.name}: {error}"]})
+
+
+def preview_datasets(csv_one, csv_two):
+    """Return preview tables and a small status message."""
+    left = _preview_csv(csv_one)
+    right = _preview_csv(csv_two)
+    message = (
+        f"Preview ready. File 1: {_display_name(csv_one) or 'default / missing'} | "
+        f"File 2: {_display_name(csv_two) or 'default / missing'}"
     )
+    return left, right, message
 
 
-def on_table_select(choice: str):
-    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 _remove_runtime_install_cells(notebook_node):
+    """Remove shell install cells because Hugging Face installs from requirements.txt."""
+    cleaned_cells = []
+    removed_count = 0
+    install_pattern = re.compile(r"^\s*!pip\s+install|^\s*%pip\s+install", re.IGNORECASE)
 
+    for cell in notebook_node.cells:
+        if cell.get("cell_type") != "code":
+            cleaned_cells.append(cell)
+            continue
+        source = cell.get("source", "")
+        if install_pattern.search(source.strip()):
+            removed_count += 1
+            continue
+        cleaned_cells.append(cell)
 
-# =========================================================
-# KPI LOADER
-# =========================================================
-
-def load_kpis() -> Dict[str, Any]:
-    for candidate in [PY_TAB_DIR / "kpis.json", PY_FIG_DIR / "kpis.json"]:
-        if candidate.exists():
-            try:
-                return _read_json(candidate)
-            except Exception:
-                pass
-    return {}
-
-
-# =========================================================
-# AI DASHBOARD -- LLM picks what to display
-# =========================================================
-
-DASHBOARD_SYSTEM = """You are an AI dashboard assistant for a book-sales analytics app.
-The user asks questions or requests about their data. You have access to pre-computed
-artifacts from a Python analysis pipeline.
-
-AVAILABLE ARTIFACTS (only reference ones that exist):
-{artifacts_json}
+    notebook_node.cells = cleaned_cells
+    return removed_count
 
-KPI SUMMARY: {kpis_json}
 
-YOUR JOB:
-1. Answer the user's question conversationally using the KPIs and your knowledge of the artifacts.
-2. At the END of your response, output a JSON block (fenced with ```json ... ```) that tells
-   the dashboard which artifact to display. The JSON must have this shape:
-   {{"show": "figure"|"table"|"none", "scope": "python", "filename": "..."}}
+def _prepare_run_directory(notebook_file, csv_one, csv_two):
+    """Create a clean temp folder and standardize filenames for the notebook."""
+    run_dir = Path(tempfile.mkdtemp(prefix="hf_notebook_run_"))
 
-   - Use "show": "figure" to display a chart image.
-   - Use "show": "table" to display a CSV/JSON table.
-   - Use "show": "none" if no artifact is relevant.
+    notebook_source = _resolve_uploaded_path(notebook_file) or DEFAULT_NOTEBOOK
+    if not notebook_source.exists():
+        raise FileNotFoundError("No notebook found. Upload one or include analysis_notebook.ipynb.")
 
-RULES:
-- If the user asks about sales trends or forecasting by title, show sales_trends or arima figures.
-- If the user asks about sentiment, show sentiment figure or sentiment_counts table.
-- If the user asks about forecast accuracy or ARIMA, show arima figures.
-- If the user asks about top sellers, show top_titles_by_units_sold.csv.
-- If the user asks a general data question, pick the most relevant artifact.
-- Keep your answer concise (2-4 sentences), then the JSON block.
-"""
-
-JSON_BLOCK_RE = re.compile(r"```json\s*(\{.*?\})\s*```", re.DOTALL)
-FALLBACK_JSON_RE = re.compile(r"\{[^{}]*\"show\"[^{}]*\}", re.DOTALL)
+    notebook_target = run_dir / "analysis_notebook.ipynb"
+    shutil.copy2(notebook_source, notebook_target)
 
+    csv_sources = [
+        _resolve_uploaded_path(csv_one) or DEFAULT_CSVS[0],
+        _resolve_uploaded_path(csv_two) or DEFAULT_CSVS[1],
+    ]
 
-def _parse_display_directive(text: str) -> Dict[str, str]:
-    m = JSON_BLOCK_RE.search(text)
-    if m:
-        try:
-            return json.loads(m.group(1))
-        except json.JSONDecodeError:
-            pass
-    m = FALLBACK_JSON_RE.search(text)
-    if m:
-        try:
-            return json.loads(m.group(0))
-        except json.JSONDecodeError:
-            pass
-    return {"show": "none"}
+    for source, expected_name in zip(csv_sources, EXPECTED_DATASET_NAMES):
+        if not Path(source).exists():
+            raise FileNotFoundError(
+                f"Missing dataset: {expected_name}. Upload it or keep the bundled default file."
+            )
+        shutil.copy2(source, run_dir / expected_name)
 
+    return run_dir, notebook_target
 
-def _clean_response(text: str) -> str:
-    """Strip the JSON directive block from the displayed response."""
-    return JSON_BLOCK_RE.sub("", text).strip()
 
+def _extract_notebook_outputs(executed_notebook):
+    """Collect text and tables from executed notebook cells."""
+    text_chunks = []
+    tables = []
 
-def _n8n_call(msg: str) -> Tuple[str, Dict]:
-    """Call the student's n8n webhook and return (reply, directive)."""
-    import requests as req
+    for cell in executed_notebook.cells:
+        if cell.get("cell_type") != "code":
+            continue
+        for output in cell.get("outputs", []):
+            if output.get("output_type") == "stream":
+                text_chunks.append(output.get("text", ""))
+            elif output.get("output_type") in {"execute_result", "display_data"}:
+                data = output.get("data", {})
+                if "text/plain" in data:
+                    text_chunks.append(str(data["text/plain"]))
+                if "text/html" in data:
+                    try:
+                        tables.append(pd.read_html(io.StringIO(data["text/html"]))[0])
+                    except Exception:
+                        pass
+            elif output.get("output_type") == "error":
+                traceback_text = "\n".join(output.get("traceback", []))
+                text_chunks.append(traceback_text)
+
+    combined_text = "\n\n".join(chunk.strip() for chunk in text_chunks if str(chunk).strip())
+    if not combined_text:
+        combined_text = "Notebook executed, but no text output was captured."
+
+    return combined_text, tables
+
+
+def _save_output_bundle(run_dir):
+    """Zip everything created during execution for download."""
+    zip_path = run_dir / "execution_outputs.zip"
+    with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED) as zip_file:
+        for item in run_dir.rglob("*"):
+            if item == zip_path:
+                continue
+            if item.is_file():
+                zip_file.write(item, item.relative_to(run_dir))
+    return zip_path
+
+
+def run_analysis(notebook_file, csv_one, csv_two):
+    """Run the notebook on the selected files and return UI-friendly outputs."""
     try:
-        resp = req.post(N8N_WEBHOOK_URL, json={"question": msg}, timeout=20)
-        data = resp.json()
-        answer = data.get("answer", "No response from n8n workflow.")
-        chart = data.get("chart", "none")
-        if chart and chart != "none":
-            return answer, {"show": "figure", "chart": chart}
-        return answer, {"show": "none"}
-    except Exception as e:
-        return f"n8n error: {e}. Falling back to keyword matching.", None
-
-
-def ai_chat(user_msg: str, history: list):
-    """Chat function for the AI Dashboard tab."""
-    if not user_msg or not user_msg.strip():
-        return history, "", None, None
-
-    idx = artifacts_index()
-    kpis = load_kpis()
-
-    # Priority: n8n webhook > HF LLM > keyword fallback
-    if N8N_WEBHOOK_URL:
-        reply, directive = _n8n_call(user_msg)
-        if directive is None:
-            reply_fb, directive = _keyword_fallback(user_msg, idx, kpis)
-            reply += "\n\n" + reply_fb
-    elif not LLM_ENABLED:
-        reply, directive = _keyword_fallback(user_msg, idx, kpis)
-    else:
-        system = DASHBOARD_SYSTEM.format(
-            artifacts_json=json.dumps(idx, indent=2),
-            kpis_json=json.dumps(kpis, indent=2) if kpis else "(no KPIs yet, run the pipeline first)",
-        )
-        msgs = [{"role": "system", "content": system}]
-        for entry in (history or [])[-6:]:
-            msgs.append(entry)
-        msgs.append({"role": "user", "content": user_msg})
-
-        try:
-            r = llm_client.chat_completion(
-                model=MODEL_NAME,
-                messages=msgs,
-                temperature=0.3,
-                max_tokens=600,
-                stream=False,
-            )
-            raw = (
-                r["choices"][0]["message"]["content"]
-                if isinstance(r, dict)
-                else r.choices[0].message.content
-            )
-            directive = _parse_display_directive(raw)
-            reply = _clean_response(raw)
-        except Exception as e:
-            reply = f"LLM error: {e}. Falling back to keyword matching."
-            reply_fb, directive = _keyword_fallback(user_msg, idx, kpis)
-            reply += "\n\n" + reply_fb
-
-    # Resolve artifacts — build interactive Plotly charts when possible
-    chart_out = None
-    tab_out = None
-    show = directive.get("show", "none")
-    fname = directive.get("filename", "")
-    chart_name = directive.get("chart", "")
-
-    # Interactive chart builders keyed by name
-    chart_builders = {
-        "sales": build_sales_chart,
-        "sentiment": build_sentiment_chart,
-        "top_sellers": build_top_sellers_chart,
-    }
-
-    if chart_name and chart_name in chart_builders:
-        chart_out = chart_builders[chart_name]()
-    elif show == "figure" and fname:
-        # Fallback: try to match filename to a chart builder
-        if "sales_trend" in fname:
-            chart_out = build_sales_chart()
-        elif "sentiment" in fname:
-            chart_out = build_sentiment_chart()
-        elif "arima" in fname or "forecast" in fname:
-            chart_out = build_sales_chart()  # closest interactive equivalent
-        else:
-            chart_out = _empty_chart(f"No interactive chart for {fname}")
-
-    if show == "table" and fname:
-        fp = PY_TAB_DIR / fname
-        if fp.exists():
-            tab_out = _load_table_safe(fp)
-        else:
-            reply += f"\n\n*(Could not find table: {fname})*"
-
-    new_history = (history or []) + [
-        {"role": "user", "content": user_msg},
-        {"role": "assistant", "content": reply},
-    ]
-
-    return new_history, "", chart_out, tab_out
+        run_dir, notebook_path = _prepare_run_directory(notebook_file, csv_one, csv_two)
 
+        with notebook_path.open("r", encoding="utf-8") as notebook_handle:
+            notebook_node = nbformat.read(notebook_handle, as_version=4)
 
-def _keyword_fallback(msg: str, idx: Dict, kpis: Dict) -> Tuple[str, Dict]:
-    """Simple keyword matcher when LLM is unavailable."""
-    msg_lower = msg.lower()
+        removed_cells = _remove_runtime_install_cells(notebook_node)
 
-    if not idx["python"]["figures"] and not idx["python"]["tables"]:
-        return (
-            "No artifacts found yet. Please run the pipeline first (Tab 1), "
-            "then come back here to explore the results.",
-            {"show": "none"},
+        client = NotebookClient(
+            notebook_node,
+            timeout=900,
+            kernel_name="python3",
+            resources={"metadata": {"path": str(run_dir)}},
+            allow_errors=False,
         )
+        client.execute()
 
-    kpi_text = ""
-    if kpis:
-        total = kpis.get("total_units_sold", 0)
-        kpi_text = (
-            f"Quick summary: **{kpis.get('n_titles', '?')}** book titles across "
-            f"**{kpis.get('n_months', '?')}** months, with **{total:,.0f}** total units sold."
-        )
+        executed_notebook_path = run_dir / "executed_analysis_notebook.ipynb"
+        with executed_notebook_path.open("w", encoding="utf-8") as notebook_handle:
+            nbformat.write(notebook_node, notebook_handle)
 
-    if any(w in msg_lower for w in ["trend", "sales trend", "monthly sale"]):
-        return (
-            f"Here are the sales trends. {kpi_text}",
-            {"show": "figure", "chart": "sales"},
-        )
+        log_text, tables = _extract_notebook_outputs(notebook_node)
+        output_zip = _save_output_bundle(run_dir)
 
-    if any(w in msg_lower for w in ["sentiment", "review", "positive", "negative"]):
-        return (
-            f"Here is the sentiment distribution across sampled book titles. {kpi_text}",
-            {"show": "figure", "chart": "sentiment"},
-        )
+        first_table = tables[0] if tables else pd.DataFrame({"Info": ["No table output detected."]})
+        second_table = tables[1] if len(tables) > 1 else pd.DataFrame({"Info": ["No second table detected."]})
 
-    if any(w in msg_lower for w in ["arima", "forecast", "predict"]):
-        return (
-            f"Here are the sales trends and forecasts. {kpi_text}",
-            {"show": "figure", "chart": "sales"},
-        )
+        summary = {
+            "status": "success",
+            "removed_install_cells": removed_cells,
+            "notebook_used": _display_name(notebook_file) or DEFAULT_NOTEBOOK.name,
+            "dataset_1": _display_name(csv_one) or DEFAULT_CSVS[0].name,
+            "dataset_2": _display_name(csv_two) or DEFAULT_CSVS[1].name,
+            "run_directory": str(run_dir),
+        }
 
-    if any(w in msg_lower for w in ["top", "best sell", "popular", "rank"]):
         return (
-            f"Here are the top-selling titles by units sold. {kpi_text}",
-            {"show": "table", "scope": "python", "filename": "top_titles_by_units_sold.csv"},
+            "✅ Execution finished successfully.",
+            log_text[:15000],
+            first_table,
+            second_table,
+            str(executed_notebook_path),
+            str(output_zip),
+            json.dumps(summary, indent=2),
         )
 
-    if any(w in msg_lower for w in ["price", "pricing", "decision"]):
+    except CellExecutionError as error:
         return (
-            f"Here are the pricing decisions. {kpi_text}",
-            {"show": "table", "scope": "python", "filename": "pricing_decisions.csv"},
+            "❌ Notebook execution failed.",
+            str(error),
+            pd.DataFrame({"Error": ["Notebook cell execution failed. See log above."]}),
+            pd.DataFrame({"Error": ["No second table because execution stopped early."]}),
+            None,
+            None,
+            json.dumps({"status": "failed", "reason": "CellExecutionError"}, indent=2),
         )
-
-    if any(w in msg_lower for w in ["dashboard", "overview", "summary", "kpi"]):
+    except Exception as error:
         return (
-            f"Dashboard overview: {kpi_text}\n\nAsk me about sales trends, sentiment, forecasts, "
-            "pricing, or top sellers to see specific visualizations.",
-            {"show": "table", "scope": "python", "filename": "df_dashboard.csv"},
+            "❌ App error.",
+            str(error),
+            pd.DataFrame({"Error": [f"App failed before completion: {error}"]}),
+            pd.DataFrame({"Error": ["No second table available."]}),
+            None,
+            None,
+            json.dumps({"status": "failed", "reason": str(error)}, indent=2),
         )
 
-    # Default
-    return (
-        f"I can show you various analyses. {kpi_text}\n\n"
-        "Try asking about: **sales trends**, **sentiment**, **ARIMA forecasts**, "
-        "**pricing decisions**, **top sellers**, or **dashboard overview**.",
-        {"show": "none"},
-    )
-
-
-# =========================================================
-# KPI CARDS (BubbleBusters style)
-# =========================================================
 
-def render_kpi_cards() -> str:
-    kpis = load_kpis()
-    if not kpis:
-        return (
-            '<div style="background:rgba(255,255,255,.65);backdrop-filter:blur(16px);'
-            'border-radius:20px;padding:28px;text-align:center;'
-            'border:1.5px solid rgba(255,255,255,.7);'
-            'box-shadow:0 8px 32px rgba(124,92,191,.08);">'
-            '<div style="font-size:36px;margin-bottom:10px;">📊</div>'
-            '<div style="color:#a48de8;font-size:14px;'
-            'font-weight:800;margin-bottom:6px;">No data yet</div>'
-            '<div style="color:#9d8fc4;font-size:12px;">'
-            'Run the pipeline to populate these cards.</div>'
-            '</div>'
-        )
+CUSTOM_CSS = """
+#run-btn {min-height: 52px; font-size: 18px;}
+.gradio-container {max-width: 1200px !important;}
+"""
 
-    def card(icon, label, value, colour):
-        return f"""
-        <div style="background:rgba(255,255,255,.72);backdrop-filter:blur(16px);
-                    border-radius:20px;padding:18px 14px 16px;text-align:center;
-                    border:1.5px solid rgba(255,255,255,.8);
-                    box-shadow:0 4px 16px rgba(124,92,191,.08);
-                    border-top:3px solid {colour};">
-            <div style="font-size:26px;margin-bottom:7px;line-height:1;">{icon}</div>
-            <div style="color:#9d8fc4;font-size:9.5px;text-transform:uppercase;
-                        letter-spacing:1.8px;margin-bottom:7px;font-weight:800;">{label}</div>
-            <div style="color:#2d1f4e;font-size:16px;font-weight:800;">{value}</div>
-        </div>"""
-
-    kpi_config = [
-        ("n_titles",         "📚", "Book Titles",  "#a48de8"),
-        ("n_months",         "📅", "Time Periods", "#7aa6f8"),
-        ("total_units_sold", "📦", "Units Sold",   "#6ee7c7"),
-        ("total_revenue",    "💰", "Revenue",      "#3dcba8"),
-    ]
+with gr.Blocks(css=CUSTOM_CSS, theme=gr.themes.Soft()) as demo:
+    gr.Markdown(
+        """
+        # Interactive Notebook Runner
+        Upload a Jupyter notebook and two CSV files, preview the datasets, then run the notebook directly in the Space.
 
-    html = (
-        '<div style="display:grid;grid-template-columns:repeat(auto-fit,minmax(140px,1fr));'
-        'gap:12px;margin-bottom:24px;">'
+        **Default behavior:** if you leave uploads empty, the app uses the bundled class notebook and bundled CSV files.
+        """
     )
-    for key, icon, label, colour in kpi_config:
-        val = kpis.get(key)
-        if val is None:
-            continue
-        if isinstance(val, (int, float)) and val > 100:
-            val = f"{val:,.0f}"
-        html += card(icon, label, str(val), colour)
-    # Extra KPIs not in config
-    known = {k for k, *_ in kpi_config}
-    for key, val in kpis.items():
-        if key not in known:
-            label = key.replace("_", " ").title()
-            if isinstance(val, (int, float)) and val > 100:
-                val = f"{val:,.0f}"
-            html += card("📈", label, str(val), "#8fa8f8")
-    html += "</div>"
-    return html
-
-
-# =========================================================
-# INTERACTIVE PLOTLY CHARTS (BubbleBusters style)
-# =========================================================
-
-CHART_PALETTE = ["#7c5cbf", "#2ec4a0", "#e8537a", "#e8a230", "#5e8fef",
-                 "#c45ea8", "#3dbacc", "#a0522d", "#6aaa3a", "#d46060"]
-
-def _styled_layout(**kwargs) -> dict:
-    defaults = dict(
-        template="plotly_white",
-        paper_bgcolor="rgba(255,255,255,0.95)",
-        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=70),
-        legend=dict(
-            orientation="h", yanchor="bottom", y=1.02, xanchor="right", x=1,
-            bgcolor="rgba(255,255,255,0.92)",
-            bordercolor="rgba(124,92,191,0.35)", borderwidth=1,
-        ),
-        title=dict(font=dict(size=15, color="#4b2d8a")),
-    )
-    defaults.update(kwargs)
-    return defaults
-
-
-def _empty_chart(title: str) -> go.Figure:
-    fig = go.Figure()
-    fig.update_layout(
-        title=title, height=420, template="plotly_white",
-        paper_bgcolor="rgba(255,255,255,0.95)",
-        annotations=[dict(text="Run the pipeline to generate data",
-            x=0.5, y=0.5, xref="paper", yref="paper", showarrow=False,
-            font=dict(size=14, color="rgba(124,92,191,0.5)"))],
-    )
-    return fig
-
-
-def build_sales_chart() -> go.Figure:
-    path = PY_TAB_DIR / "df_dashboard.csv"
-    if not path.exists():
-        return _empty_chart("Sales Trends — run the pipeline first")
-    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)
-    val_cols = [c for c in df.columns if c != date_col and df[c].dtype in ("float64", "int64")]
-    if not date_col or not val_cols:
-        return _empty_chart("Could not auto-detect columns in df_dashboard.csv")
-    df[date_col] = pd.to_datetime(df[date_col], errors="coerce")
-    fig = go.Figure()
-    for i, col in enumerate(val_cols):
-        fig.add_trace(go.Scatter(
-            x=df[date_col], y=df[col], name=col.replace("_", " ").title(),
-            mode="lines+markers", line=dict(color=CHART_PALETTE[i % len(CHART_PALETTE)], width=2),
-            marker=dict(size=4),
-            hovertemplate=f"<b>{col.replace('_',' ').title()}</b><br>%{{x|%b %Y}}: %{{y:,.0f}}<extra></extra>",
-        ))
-    fig.update_layout(**_styled_layout(height=450, hovermode="x unified",
-                                        title=dict(text="Monthly Overview")))
-    fig.update_xaxes(gridcolor="rgba(124,92,191,0.15)", showgrid=True)
-    fig.update_yaxes(gridcolor="rgba(124,92,191,0.15)", showgrid=True)
-    return fig
-
-
-def build_sentiment_chart() -> go.Figure:
-    path = PY_TAB_DIR / "sentiment_counts_sampled.csv"
-    if not path.exists():
-        return _empty_chart("Sentiment Distribution — run the pipeline first")
-    df = pd.read_csv(path)
-    title_col = df.columns[0]
-    sent_cols = [c for c in ["negative", "neutral", "positive"] if c in df.columns]
-    if not sent_cols:
-        return _empty_chart("No sentiment columns found in CSV")
-    colors = {"negative": "#e8537a", "neutral": "#5e8fef", "positive": "#2ec4a0"}
-    fig = go.Figure()
-    for col in sent_cols:
-        fig.add_trace(go.Bar(
-            name=col.title(), y=df[title_col], x=df[col],
-            orientation="h", marker_color=colors.get(col, "#888"),
-            hovertemplate=f"<b>{col.title()}</b>: %{{x}}<extra></extra>",
-        ))
-    fig.update_layout(**_styled_layout(
-        height=max(400, len(df) * 28), barmode="stack",
-        title=dict(text="Sentiment Distribution by Book"),
-    ))
-    fig.update_xaxes(title="Number of Reviews")
-    fig.update_yaxes(autorange="reversed")
-    return fig
-
-
-def build_top_sellers_chart() -> go.Figure:
-    path = PY_TAB_DIR / "top_titles_by_units_sold.csv"
-    if not path.exists():
-        return _empty_chart("Top Sellers — run the pipeline first")
-    df = pd.read_csv(path).head(15)
-    title_col = next((c for c in df.columns if "title" in c.lower()), df.columns[0])
-    val_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[val_col], orientation="h",
-        marker=dict(color=df[val_col], colorscale=[[0, "#c5b4f0"], [1, "#7c5cbf"]]),
-        hovertemplate="<b>%{y}</b><br>Units: %{x:,.0f}<extra></extra>",
-    ))
-    fig.update_layout(**_styled_layout(
-        height=max(400, len(df) * 30),
-        title=dict(text="Top Selling Titles"), showlegend=False,
-    ))
-    fig.update_yaxes(autorange="reversed")
-    fig.update_xaxes(title="Total Units Sold")
-    return fig
-
-
-def refresh_dashboard():
-    return render_kpi_cards(), build_sales_chart(), build_sentiment_chart(), build_top_sellers_chart()
-
-
-# =========================================================
-# UI
-# =========================================================
-
-ensure_dirs()
-
-def load_css() -> str:
-    css_path = BASE_DIR / "style.css"
-    return css_path.read_text(encoding="utf-8") if css_path.exists() else ""
-
-
-with gr.Blocks(title="AIBDM 2026 Workshop App") as demo:
 
-    gr.Markdown(
-        "# SE21 App Template\n"
-        "*This is an app template for SE21 students*",
-        elem_id="escp_title",
-    )
+    with gr.Row():
+        notebook_input = gr.File(label="Notebook (.ipynb)", file_types=[".ipynb"])
+        csv_one_input = gr.File(label="Dataset 1 (.csv)", file_types=[".csv"])
+        csv_two_input = gr.File(label="Dataset 2 (.csv)", file_types=[".csv"])
 
-    # ===========================================================
-    # TAB 1 -- Pipeline Runner
-    # ===========================================================
-    with gr.Tab("Pipeline Runner"):
-        gr.Markdown()
+    with gr.Row():
+        preview_button = gr.Button("Refresh previews")
+        run_button = gr.Button("Run notebook", elem_id="run-btn")
 
-        with gr.Row():
-            with gr.Column(scale=1):
-                btn_nb1 = gr.Button("Step 1: Data Creation", variant="secondary")
-            with gr.Column(scale=1):
-                btn_nb2 = gr.Button("Step 2: Python Analysis", variant="secondary")
+    preview_status = gr.Textbox(label="Preview status", interactive=False)
 
+    with gr.Tab("Dataset previews"):
         with gr.Row():
-            btn_all = gr.Button("Run Full Pipeline (Both Steps)", variant="primary")
-
-        run_log = gr.Textbox(
-            label="Execution Log",
-            lines=18,
-            max_lines=30,
-            interactive=False,
-        )
-
-        btn_nb1.click(run_datacreation, outputs=[run_log])
-        btn_nb2.click(run_pythonanalysis, outputs=[run_log])
-        btn_all.click(run_full_pipeline, outputs=[run_log])
-
-    # ===========================================================
-    # TAB 2 -- Dashboard (KPIs + Interactive Charts + Gallery)
-    # ===========================================================
-    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 (from notebooks)")
-        gallery = gr.Gallery(
-            label="Generated Figures",
-            columns=2,
-            height=480,
-            object_fit="contain",
-        )
+            preview_table_one = gr.Dataframe(label="Preview: dataset 1", interactive=False)
+            preview_table_two = gr.Dataframe(label="Preview: dataset 2", interactive=False)
 
-        gr.Markdown("#### Data Tables")
-        table_dropdown = gr.Dropdown(
-            label="Select a table to view",
-            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],
-        )
-
-    # ===========================================================
-    # TAB 3 -- AI Dashboard
-    # ===========================================================
-    with gr.Tab('"AI" Dashboard'):
-        _ai_status = (
-            "Connected to your **n8n workflow**." if N8N_WEBHOOK_URL
-            else "**LLM active.**" if LLM_ENABLED
-            else "Using **keyword matching**. Upgrade options: "
-                 "set `N8N_WEBHOOK_URL` to connect your n8n workflow, "
-                 "or set `HF_API_KEY` for direct LLM access."
-        )
-        gr.Markdown(
-            "### Ask questions, get interactive visualisations\n\n"
-            f"Type a question and the system will pick the right interactive chart or table. {_ai_status}"
-        )
-
-        with gr.Row(equal_height=True):
-            with gr.Column(scale=1):
-                chatbot = gr.Chatbot(
-                    label="Conversation",
-                    height=380,
-                )
-                user_input = gr.Textbox(
-                    label="Ask about your data",
-                    placeholder="e.g. Show me sales trends / What are the top sellers? / Sentiment analysis",
-                    lines=1,
-                )
-                gr.Examples(
-                    examples=[
-                        "Show me the sales trends",
-                        "What does the sentiment look like?",
-                        "Which titles sell the most?",
-                        "Show the ARIMA forecasts",
-                        "What are 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],
-        )
+    with gr.Tab("Execution results"):
+        status_box = gr.Textbox(label="Run status", interactive=False)
+        execution_log = gr.Textbox(label="Execution log", lines=18, interactive=False)
+        with gr.Row():
+            output_table_one = gr.Dataframe(label="Detected output table 1", interactive=False)
+            output_table_two = gr.Dataframe(label="Detected output table 2", interactive=False)
+        run_metadata = gr.Code(label="Run metadata", language="json")
+
+    with gr.Tab("Downloads"):
+        executed_notebook_file = gr.File(label="Executed notebook")
+        execution_zip_file = gr.File(label="ZIP of all outputs")
+
+    preview_button.click(
+        fn=preview_datasets,
+        inputs=[csv_one_input, csv_two_input],
+        outputs=[preview_table_one, preview_table_two, preview_status],
+    )
 
+    run_button.click(
+        fn=run_analysis,
+        inputs=[notebook_input, csv_one_input, csv_two_input],
+        outputs=[
+            status_box,
+            execution_log,
+            output_table_one,
+            output_table_two,
+            executed_notebook_file,
+            execution_zip_file,
+            run_metadata,
+        ],
+    )
 
-demo.launch(css=load_css(), allowed_paths=[str(BASE_DIR)])
+demo.launch()

requirements.txt

@@ -1,17 +1,9 @@
-gradio==6.0.0
-pandas>=2.0.0
-numpy>=1.24.0
-matplotlib>=3.7.0
-seaborn>=0.13.0
-statsmodels>=0.14.0
-scikit-learn>=1.3.0
-papermill>=2.5.0
-nbformat>=5.9.0
-pillow>=10.0.0
-requests>=2.31.0
-beautifulsoup4>=4.12.0
-vaderSentiment>=3.3.2
-huggingface_hub>=0.20.0
-textblob>=0.18.0
-faker>=20.0.0
-plotly>=5.18.0
+gradio==4.44.0
+pandas==2.2.2
+nbformat==5.10.4
+nbclient==0.10.0
+ipykernel==6.29.5
+lxml==5.3.0
+matplotlib==3.9.2
+numpy==2.1.1
+vaderSentiment==3.3.2