Update app.py

app.py

@@ -1,61 +1,37 @@
 import time
-import io
-import traceback
-from typing import Dict, Callable, Any, Tuple
-
 import numpy as np
 import pandas as pd
 import duckdb
 import gradio as gr
 import matplotlib.pyplot as plt
 from PIL import Image
-
-# ----------------- 1. Global Setup -----------------
+import io
+import os
 
 duckdb_con = duckdb.connect(database=":memory:")
 
-# ----------------- 2. Data Generation & Loading -----------------
+# ----------------------------------------------------------
+# Synthetic Data Generator
+# ----------------------------------------------------------
 
-def generate_data(n_rows, n_groups=50):
+def generate_data(n_rows: int, n_groups: int = 50) -> pd.DataFrame:
     rng = np.random.default_rng(42)
-    ids = np.arange(n_rows, dtype=np.int64)
-
+    ids = np.arange(n_rows)
     categories = rng.integers(0, n_groups, size=n_rows)
-    categories = np.array(["cat_" + str(c) for c in categories], dtype=object)
-
+    categories = np.array([f"cat_{c}" for c in categories])
     value1 = rng.normal(0, 1, size=n_rows)
     value2 = rng.normal(10, 5, size=n_rows)
-
-    null_mask = rng.random(n_rows) < 0.05
-    value1[null_mask] = np.nan
-
     start_date = np.datetime64("2020-01-01")
     dates = start_date + rng.integers(0, 365, size=n_rows).astype("timedelta64[D]")
 
-    df = pd.DataFrame(
-        {
-            "id": ids,
-            "category": categories,
-            "value1": value1,
-            "value2": value2,
-            "date": dates,
-        }
+    return pd.DataFrame(
+        {"id": ids, "category": categories, "value1": value1, "value2": value2, "date": dates}
     )
-    return df
 
-def load_custom_dataset(file) -> pd.DataFrame:
-    if file is None:
-        raise ValueError("No file uploaded.")
-    name = file.name.lower()
-    if name.endswith(".csv"):
-        return pd.read_csv(file.name)
-    if name.endswith(".parquet"):
-        return pd.read_parquet(file.name)
-    if name.endswith(".arrow") or name.endswith(".feather"):
-        return pd.read_feather(file.name)
-    raise ValueError("Unsupported file format. Use CSV, Parquet, or Arrow/Feather.")
 
-# ----------------- 3. Timing Utils -----------------
+# ----------------------------------------------------------
+# Timing utility
+# ----------------------------------------------------------
 
 def time_function(fn, repeats=3):
     repeats = int(repeats)
@@ -65,106 +41,57 @@ def time_function(fn, repeats=3):
         fn()
         end = time.perf_counter()
         times.append(end - start)
-    return float(np.mean(times)), float(np.std(times)), [float(t) for t in times]
+    return np.mean(times), np.std(times), times
 
-def build_result(pm, ps, pr, dm, ds, dr):
-    if dm > 1e-9:
-        speedup = pm / dm
-    else:
-        speedup = 0.0
-    return {
-        "pandas_mean_s": pm,
-        "pandas_std_s": ps,
-        "duckdb_mean_s": dm,
-        "duckdb_std_s": ds,
-        "speedup": speedup,
-        "raw_pandas_runs": pr,
-        "raw_duckdb_runs": dr,
-    }
 
-# ----------------- 4. Benchmarks -----------------
+# ----------------------------------------------------------
+# Benchmark Operations (Compute + I/O)
+# ----------------------------------------------------------
 
-def bench_filter_simple(df, repeats=3):
+# ---- Filter ----
+def bench_filter(df, repeats=3):
     def pandas_op():
-        _ = df[(df["value1"] > 0.5) & (df["category"] == "cat_1")]
+        _ = df[(df["value1"] > 0.5) & (df["category"] == df["category"].iloc[0])]
 
     def duckdb_op():
         duckdb_con.register("df", df)
-        duckdb_con.execute(
-            "SELECT * FROM df WHERE value1 > 0.5 AND category = 'cat_1';"
-        ).fetchdf()
+        duckdb_con.execute(f"""
+            SELECT *
+            FROM df
+            WHERE value1 > 0.5
+              AND category='{df['category'].iloc[0]}'
+        """).fetchdf()
 
-    pm, ps, pr = time_function(pandas_op, repeats)
-    dm, ds, dr = time_function(duckdb_op, repeats)
-    return build_result(pm, ps, pr, dm, ds, dr)
+    p_mean, p_std, p_all = time_function(pandas_op, repeats)
+    d_mean, d_std, d_all = time_function(duckdb_op, repeats)
 
-def bench_filter_complex(df, repeats=3):
-    def pandas_op():
-        _ = df[
-            (df["value1"] > 0)
-            & (df["value2"] < 12)
-            & (df["date"].between("2020-03-01", "2020-09-30"))
-        ]
+    return build_result("Filter rows", p_mean, p_std, p_all, d_mean, d_std, d_all)
 
-    def duckdb_op():
-        duckdb_con.register("df", df)
-        duckdb_con.execute(
-            "SELECT * FROM df "
-            "WHERE value1 > 0 "
-            "AND value2 < 12 "
-            "AND date BETWEEN DATE '2020-03-01' AND DATE '2020-09-30';"
-        ).fetchdf()
-
-    pm, ps, pr = time_function(pandas_op, repeats)
-    dm, ds, dr = time_function(duckdb_op, repeats)
-    return build_result(pm, ps, pr, dm, ds, dr)
-
-def bench_groupby_basic(df, repeats=3):
-    def pandas_op():
-        _ = df.groupby("category").agg(
-            mean_value1=("value1", "mean"),
-            sum_value2=("value2", "sum"),
-            cnt=("id", "count"),
-        )
 
-    def duckdb_op():
-        duckdb_con.register("df", df)
-        duckdb_con.execute(
-            "SELECT category, "
-            "AVG(value1) AS mean_value1, "
-            "SUM(value2) AS sum_value2, "
-            "COUNT(*) AS cnt "
-            "FROM df GROUP BY category;"
-        ).fetchdf()
-
-    pm, ps, pr = time_function(pandas_op, repeats)
-    dm, ds, dr = time_function(duckdb_op, repeats)
-    return build_result(pm, ps, pr, dm, ds, dr)
-
-def bench_groupby_having(df, repeats=3):
+# ---- Groupby ----
+def bench_groupby(df, repeats=3):
     def pandas_op():
-        agg = df.groupby("category").agg(mean_value1=("value1", "mean"))
-        _ = agg[agg["mean_value1"] > 0]
+        _ = df.groupby("category")[["value1", "value2"]].mean()
 
     def duckdb_op():
         duckdb_con.register("df", df)
-        duckdb_con.execute(
-            "SELECT category, AVG(value1) AS mean_value1 "
-            "FROM df GROUP BY category HAVING AVG(value1) > 0;"
-        ).fetchdf()
+        duckdb_con.execute("""
+            SELECT category, AVG(value1), AVG(value2)
+            FROM df GROUP BY category
+        """).fetchdf()
+
+    p_mean, p_std, p_all = time_function(pandas_op, repeats)
+    d_mean, d_std, d_all = time_function(duckdb_op, repeats)
+
+    return build_result("Groupby mean", p_mean, p_std, p_all, d_mean, d_std, d_all)
 
-    pm, ps, pr = time_function(pandas_op, repeats)
-    dm, ds, dr = time_function(duckdb_op, repeats)
-    return build_result(pm, ps, pr, dm, ds, dr)
 
+# ---- Join ----
 def bench_join(df, repeats=3):
     categories = df["category"].unique()
     rng = np.random.default_rng(123)
     dim_df = pd.DataFrame(
-        {
-            "category": categories,
-            "weight": rng.uniform(0.5, 2.0, size=len(categories)),
-        }
+        {"category": categories, "weight": rng.uniform(0.5, 2.0, len(categories))}
     )
 
     def pandas_op():
@@ -173,445 +100,243 @@ def bench_join(df, repeats=3):
     def duckdb_op():
         duckdb_con.register("df", df)
         duckdb_con.register("dim_df", dim_df)
-        duckdb_con.execute(
-            "SELECT d.*, dim.weight "
-            "FROM df d LEFT JOIN dim_df dim "
-            "ON d.category = dim.category;"
-        ).fetchdf()
+        duckdb_con.execute("""
+            SELECT d.*, dim.weight
+            FROM df d
+            LEFT JOIN dim_df dim
+            ON d.category = dim.category
+        """).fetchdf()
 
-    pm, ps, pr = time_function(pandas_op, repeats)
-    dm, ds, dr = time_function(duckdb_op, repeats)
-    return build_result(pm, ps, pr, dm, ds, dr)
+    p_mean, p_std, p_all = time_function(pandas_op, repeats)
+    d_mean, d_std, d_all = time_function(duckdb_op, repeats)
 
-def bench_order_by(df, repeats=3):
+    return build_result("Join on category", p_mean, p_std, p_all, d_mean, d_std, d_all)
+
+
+# ---- Read CSV ----
+def bench_read_csv(temp_csv_path, repeats=3):
     def pandas_op():
-        _ = df.sort_values(["value1", "date"], ascending=[False, True])
+        _ = pd.read_csv(temp_csv_path)
 
     def duckdb_op():
-        duckdb_con.register("df", df)
-        duckdb_con.execute(
-            "SELECT * FROM df ORDER BY value1 DESC, date ASC;"
-        ).fetchdf()
+        _ = duckdb.read_csv_auto(temp_csv_path)
 
-    pm, ps, pr = time_function(pandas_op, repeats)
-    dm, ds, dr = time_function(duckdb_op, repeats)
-    return build_result(pm, ps, pr, dm, ds, dr)
+    p_mean, p_std, p_all = time_function(pandas_op, repeats)
+    d_mean, d_std, d_all = time_function(duckdb_op, repeats)
 
-def bench_window_row_number(df, repeats=3):
+    return build_result("Read CSV", p_mean, p_std, p_all, d_mean, d_std, d_all)
+
+
+# ---- Read Parquet ----
+def bench_read_parquet(temp_parquet_path, repeats=3):
     def pandas_op():
-        temp = df.sort_values(["category", "value1"], ascending=[True, False]).copy()
-        temp["rn"] = temp.groupby("category").cumcount() + 1
-        _ = temp
+        _ = pd.read_parquet(temp_parquet_path)
 
     def duckdb_op():
-        duckdb_con.register("df", df)
-        duckdb_con.execute(
-            "SELECT *, "
-            "ROW_NUMBER() OVER (PARTITION BY category ORDER BY value1 DESC) AS rn "
-            "FROM df;"
-        ).fetchdf()
+        _ = duckdb.read_parquet(temp_parquet_path)
 
-    pm, ps, pr = time_function(pandas_op, repeats)
-    dm, ds, dr = time_function(duckdb_op, repeats)
-    return build_result(pm, ps, pr, dm, ds, dr)
+    p_mean, p_std, p_all = time_function(pandas_op, repeats)
+    d_mean, d_std, d_all = time_function(duckdb_op, repeats)
 
-def bench_window_running_total(df, repeats=3):
-    def pandas_op():
-        temp = df.sort_values("date").copy()
-        temp["running_sum"] = temp["value1"].fillna(0).cumsum()
-        _ = temp
+    return build_result("Read Parquet", p_mean, p_std, p_all, d_mean, d_std, d_all)
 
-    def duckdb_op():
-        duckdb_con.register("df", df)
-        duckdb_con.execute(
-            "SELECT *, "
-            "SUM(COALESCE(value1, 0)) OVER (ORDER BY date "
-            "ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS running_sum "
-            "FROM df;"
-        ).fetchdf()
-
-    pm, ps, pr = time_function(pandas_op, repeats)
-    dm, ds, dr = time_function(duckdb_op, repeats)
-    return build_result(pm, ps, pr, dm, ds, dr)
-
-def bench_drop_nulls(df, repeats=3):
+
+# ---- Write Parquet ----
+def bench_write_parquet(df, repeats=3):
     def pandas_op():
-        _ = df[df["value1"].notna()]
+        df.to_parquet("temp_pd.parquet")
 
     def duckdb_op():
         duckdb_con.register("df", df)
-        duckdb_con.execute(
-            "SELECT * FROM df WHERE value1 IS NOT NULL;"
-        ).fetchdf()
+        duckdb_con.execute("COPY df TO 'temp_duck.parquet' (FORMAT PARQUET)")
 
-    pm, ps, pr = time_function(pandas_op, repeats)
-    dm, ds, dr = time_function(duckdb_op, repeats)
-    return build_result(pm, ps, pr, dm, ds, dr)
+    p_mean, p_std, p_all = time_function(pandas_op, repeats)
+    d_mean, d_std, d_all = time_function(duckdb_op, repeats)
 
-def bench_fill_nulls(df, repeats=3):
-    def pandas_op():
-        _ = df["value1"].fillna(0)
+    return build_result("Write Parquet", p_mean, p_std, p_all, d_mean, d_std, d_all)
 
-    def duckdb_op():
-        duckdb_con.register("df", df)
-        duckdb_con.execute(
-            "SELECT COALESCE(value1, 0) AS value1_filled FROM df;"
-        ).fetchdf()
 
-    pm, ps, pr = time_function(pandas_op, repeats)
-    dm, ds, dr = time_function(duckdb_op, repeats)
-    return build_result(pm, ps, pr, dm, ds, dr)
+# ----------------------------------------------------------
+# Shared result formatting
+# ----------------------------------------------------------
 
-def bench_distinct_count(df, repeats=3):
-    def pandas_op():
-        _ = df["category"].nunique()
+def build_result(op_name, p_mean, p_std, p_all, d_mean, d_std, d_all):
+    speedup = p_mean / d_mean if d_mean > 0 else None
 
-    def duckdb_op():
-        duckdb_con.register("df", df)
-        duckdb_con.execute(
-            "SELECT COUNT(DISTINCT category) AS distinct_categories FROM df;"
-        ).fetchdf()
+    return {
+        "operation": op_name,
+        "pandas_mean_s": p_mean,
+        "pandas_std_s": p_std,
+        "duckdb_mean_s": d_mean,
+        "duckdb_std_s": d_std,
+        "speedup": speedup,
+        "raw_pandas_runs": p_all,
+        "raw_duckdb_runs": d_all,
+    }
 
-    pm, ps, pr = time_function(pandas_op, repeats)
-    dm, ds, dr = time_function(duckdb_op, repeats)
-    return build_result(pm, ps, pr, dm, ds, dr)
 
-def bench_materialize_parquet(df, repeats=3):
-    def pandas_op():
-        agg = df.groupby("category").agg(
-            mean_value1=("value1", "mean"),
-            sum_value2=("value2", "sum"),
-        )
-        agg.to_parquet("pandas_grouped.parquet")
+# ----------------------------------------------------------
+# Benchmark Dispatcher
+# ----------------------------------------------------------
 
-    def duckdb_op():
-        duckdb_con.register("df", df)
-        duckdb_con.execute(
-            "CREATE OR REPLACE TEMP TABLE agg AS "
-            "SELECT category, AVG(value1) AS mean_value1, "
-            "SUM(value2) AS sum_value2 FROM df GROUP BY category;"
-        )
-        duckdb_con.execute(
-            "COPY agg TO 'duck_grouped.parquet' (FORMAT PARQUET);"
-        )
-
-    pm, ps, pr = time_function(pandas_op, repeats)
-    dm, ds, dr = time_function(duckdb_op, repeats)
-    return build_result(pm, ps, pr, dm, ds, dr)
-
-# ----------------- 5. Operation Registry -----------------
-
-OPERATIONS = {
-    "Filter (simple WHERE)": {
-        "sql": "SELECT * FROM df WHERE value1 > 0.5 AND category = 'cat_1';",
-        "pandas": 'df[(df["value1"] > 0.5) & (df["category"] == "cat_1")]',
-        "bench": bench_filter_simple,
-    },
-    "Filter (complex WHERE + date range)": {
-        "sql": (
-            "SELECT * FROM df\n"
-            "WHERE value1 > 0\n"
-            "  AND value2 < 12\n"
-            "  AND date BETWEEN DATE '2020-03-01' AND DATE '2020-09-30';"
-        ),
-        "pandas": (
-            'df[(df["value1"] > 0)\n'
-            '   & (df["value2"] < 12)\n'
-            '   & (df["date"].between("2020-03-01", "2020-09-30"))]'
-        ),
-        "bench": bench_filter_complex,
-    },
-    "Groupby (multi-agg)": {
-        "sql": (
-            "SELECT category,\n"
-            "       AVG(value1) AS mean_value1,\n"
-            "       SUM(value2) AS sum_value2,\n"
-            "       COUNT(*)    AS cnt\n"
-            "FROM df\n"
-            "GROUP BY category;"
-        ),
-        "pandas": (
-            'df.groupby("category").agg(\n'
-            '    mean_value1=("value1", "mean"),\n'
-            '    sum_value2=("value2", "sum"),\n'
-            '    cnt=("id", "count"),\n'
-            ")"
-        ),
-        "bench": bench_groupby_basic,
-    },
-    "Groupby + HAVING": {
-        "sql": (
-            "SELECT category,\n"
-            "       AVG(value1) AS mean_value1\n"
-            "FROM df\n"
-            "GROUP BY category\n"
-            "HAVING AVG(value1) > 0;"
-        ),
-        "pandas": (
-            'agg = df.groupby("category").agg(mean_value1=("value1", "mean"))\n'
-            'agg[agg["mean_value1"] > 0]'
-        ),
-        "bench": bench_groupby_having,
-    },
-    "Join (fact ⨝ dim on category)": {
-        "sql": (
-            "WITH dim AS (\n"
-            "  SELECT category, AVG(value1) AS weight\n"
-            "  FROM df\n"
-            "  GROUP BY category\n"
-            ")\n"
-            "SELECT d.*, dim.weight\n"
-            "FROM df d\n"
-            "LEFT JOIN dim ON d.category = dim.category;"
-        ),
-        "pandas": (
-            "dim = df.groupby('category', as_index=False)['value1']"
-            ".mean().rename(columns={'value1':'weight'})\n"
-            "df.merge(dim, on='category', how='left')"
-        ),
-        "bench": bench_join,
-    },
-    "Order By (value1 DESC, date ASC)": {
-        "sql": "SELECT * FROM df ORDER BY value1 DESC, date ASC;",
-        "pandas": 'df.sort_values(["value1", "date"], ascending=[False, True])',
-        "bench": bench_order_by,
-    },
-    "Window: ROW_NUMBER() PARTITION BY category": {
-        "sql": (
-            "SELECT *,\n"
-            "       ROW_NUMBER() OVER (\n"
-            "           PARTITION BY category\n"
-            "           ORDER BY value1 DESC\n"
-            "       ) AS rn\n"
-            "FROM df;"
-        ),
-        "pandas": (
-            'temp = df.sort_values(["category", "value1"], ascending=[True, False])\n'
-            'temp["rn"] = temp.groupby("category").cumcount() + 1'
-        ),
-        "bench": bench_window_row_number,
-    },
-    "Window: Running SUM(value1) OVER (ORDER BY date)": {
-        "sql": (
-            "SELECT *,\n"
-            "       SUM(COALESCE(value1, 0)) OVER (\n"
-            "           ORDER BY date\n"
-            "           ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n"
-            "       ) AS running_sum\n"
-            "FROM df;"
-        ),
-        "pandas": (
-            'temp = df.sort_values("date")\n'
-            'temp["running_sum"] = temp["value1"].fillna(0).cumsum()'
-        ),
-        "bench": bench_window_running_total,
-    },
-    "Drop NULLs (value1 IS NOT NULL)": {
-        "sql": "SELECT * FROM df WHERE value1 IS NOT NULL;",
-        "pandas": 'df[df["value1"].notna()]',
-        "bench": bench_drop_nulls,
-    },
-    "Fill NULLs (COALESCE(value1, 0))": {
-        "sql": "SELECT COALESCE(value1, 0) AS value1_filled FROM df;",
-        "pandas": 'df["value1"].fillna(0)',
-        "bench": bench_fill_nulls,
-    },
-    "Distinct count (COUNT(DISTINCT category))": {
-        "sql": "SELECT COUNT(DISTINCT category) AS distinct_categories FROM df;",
-        "pandas": 'df["category"].nunique()',
-        "bench": bench_distinct_count,
-    },
-    "Materialize Groupby → Parquet": {
-        "sql": (
-            "CREATE OR REPLACE TEMP TABLE agg AS\n"
-            "SELECT category,\n"
-            "       AVG(value1) AS mean_value1,\n"
-            "       SUM(value2) AS sum_value2\n"
-            "FROM df\n"
-            "GROUP BY category;\n"
-            "COPY agg TO 'duck_grouped.parquet' (FORMAT PARQUET);"
-        ),
-        "pandas": (
-            'agg = df.groupby("category").agg(\n'
-            '    mean_value1=("value1", "mean"),\n'
-            '    sum_value2=("value2", "sum"),\n'
-            ")\n"
-            'agg.to_parquet("pandas_grouped.parquet")'
-        ),
-        "bench": bench_materialize_parquet,
-    },
-}
-
-# ----------------- 6. Logic & Formatting -----------------
-
-def run_benchmark(operation_label, df, repeats):
-    if operation_label not in OPERATIONS:
-        raise ValueError("Unknown operation: " + str(operation_label))
-    op_meta = OPERATIONS[operation_label]
-    bench_fn = op_meta["bench"]
-    result = bench_fn(df, repeats)
-    result["operation"] = operation_label
-    return result, op_meta
+def run_benchmark(operation, df=None, repeats=3):
+    repeats = int(repeats)
+
+    if operation == "Filter": return bench_filter(df, repeats)
+    if operation == "Groupby": return bench_groupby(df, repeats)
+    if operation == "Join": return bench_join(df, repeats)
+    if operation == "Write Parquet": return bench_write_parquet(df, repeats)
+
+    raise ValueError(f"Unsupported operation: {operation}")
+
+
+# ----------------------------------------------------------
+# Chart generator (PIL Image)
+# ----------------------------------------------------------
 
 def generate_chart(result):
-    fig, ax = plt.subplots(figsize=(6, 4))
+    fig, ax = plt.subplots(figsize=(4, 3))
+
     engines = ["Pandas", "DuckDB"]
     times = [result["pandas_mean_s"], result["duckdb_mean_s"]]
-    colors = ["#1f77b4", "#ff7f0e"]
-    ax.bar(engines, times, color=colors)
+
+    ax.bar(engines, times)
     ax.set_ylabel("Time (seconds)")
-    ax.set_title(str(result.get("operation", "Benchmark Result")))
-    for i, v in enumerate(times):
-        ax.text(i, v, "{0:.4f}s".format(v), ha="center", va="bottom")
+    ax.set_title(result["operation"])
+
     buf = io.BytesIO()
     plt.tight_layout()
-    plt.savefig(buf, format="png", dpi=100)
+    plt.savefig(buf, format="png")
     buf.seek(0)
     plt.close(fig)
+
     return Image.open(buf)
 
-def format_result(result, op_meta):
+
+# ----------------------------------------------------------
+# Markdown result
+# ----------------------------------------------------------
+
+def format_result(result):
     speed = result["speedup"]
-    if speed is None or speed <= 0:
-        verdict = "Speedup could not be computed."
-    elif speed > 1:
-        verdict = "DuckDB is about {0:.2f}x faster than Pandas.".format(speed)
-    else:
-        verdict = "Pandas is about {0:.2f}x faster than DuckDB.".format(1.0 / speed)
-
-    sql_code = op_meta["sql"]
-    pandas_code = op_meta["pandas"]
-
-    raw_pandas_list = ["{0:.6f}".format(x) for x in result["raw_pandas_runs"]]
-    raw_duck_list = ["{0:.6f}".format(x) for x in result["raw_duckdb_runs"]]
-
-    raw_pandas = ", ".join(raw_pandas_list)
-    raw_duck = ", ".join(raw_duck_list)
-
-    lines = []
-    lines.append("Benchmark: " + str(result["operation"]))
-    lines.append("")
-    lines.append(
-        "Pandas mean: {0:.6f} s (std {1:.6f})".format(
-            result["pandas_mean_s"], result["pandas_std_s"]
-        )
-    )
-    lines.append(
-        "DuckDB mean: {0:.6f} s (std {1:.6f})".format(
-            result["duckdb_mean_s"], result["duckdb_std_s"]
-        )
+    verdict = (
+        f"🚀 **DuckDB is ~{speed:.2f}× faster**"
+        if speed > 1
+        else f"🐼 **Pandas is ~{1/speed:.2f}× faster**"
     )
-    lines.append("Verdict: " + verdict)
-    lines.append("")
-    lines.append("Raw timings (seconds):")
-    lines.append("  Pandas: [" + raw_pandas + "]")
-    lines.append("  DuckDB: [" + raw_duck + "]")
-    lines.append("")
-    lines.append("SQL (DuckDB):")
-    lines.append(sql_code)
-    lines.append("")
-    lines.append("Pandas equivalent:")
-    lines.append(pandas_code)
-    return "\n".join(lines)
-
-# ----------------- 7. Gradio App -----------------
+
+    md = f"""
+### 🔬 Benchmark Result — {result['operation']}
+
+| Engine | Mean (s) | Std (s) |
+|--------|----------|---------|
+| Pandas | `{result['pandas_mean_s']:.6f}` | `{result['pandas_std_s']:.6f}` |
+| DuckDB | `{result['duckdb_mean_s']:.6f}` | `{result['duckdb_std_s']:.6f}` |
+
+**Verdict:** {verdict}
+
+<details><summary>Raw timings</summary>
+
+- Pandas: `{[round(x,6) for x in result['raw_pandas_runs']]}`
+- DuckDB: `{[round(x,6) for x in result['raw_duckdb_runs']]}`
+</details>
+"""
+    return md
+
+
+# ----------------------------------------------------------
+# Helper to load custom dataset
+# ----------------------------------------------------------
+
+def load_custom_dataset(file):
+    if file.name.endswith(".csv"):
+        return pd.read_csv(file.name)
+    if file.name.endswith(".parquet"):
+        return pd.read_parquet(file.name)
+    if file.name.endswith(".arrow"):
+        return pd.read_feather(file.name)
+    raise ValueError("Unsupported file format")
+
+
+# ----------------------------------------------------------
+# Gradio App
+# ----------------------------------------------------------
 
 theme = gr.themes.Soft(primary_hue="indigo", neutral_hue="slate")
 
-with gr.Blocks(title="DuckDB vs Pandas — SQL Analytics Benchmark", theme=theme) as demo:
-    gr.Markdown(
-        "# DuckDB vs Pandas — SQL Analytics Benchmark\n\n"
-        "Compare DuckDB (SQL) and Pandas (Python) on realistic analytics operations."
-    )
+with gr.Blocks(title="DuckDB vs Pandas Benchmark", theme=theme) as demo:
+
+    gr.Markdown("# 🐼 vs 🦆 DuckDB vs Pandas — Performance Playground")
 
     with gr.Tabs():
-        with gr.Tab("Synthetic Dataset Benchmarks"):
-            with gr.Row():
-                with gr.Column(scale=1):
-                    dataset_size = gr.Radio(
-                        ["100k", "500k", "2M"],
-                        value="100k",
-                        label="Dataset Size (synthetic rows)",
-                    )
-                    operation_synth = gr.Dropdown(
-                        choices=list(OPERATIONS.keys()),
-                        value="Filter (simple WHERE)",
-                        label="Operation",
-                    )
-                    repeats_synth = gr.Slider(
-                        1,
-                        7,
-                        value=3,
-                        step=1,
-                        label="Timing repeats (average over N runs)",
-                    )
-                    btn_synth = gr.Button("Run Benchmark", variant="primary")
-
-                with gr.Column(scale=1):
-                    out_chart_synth = gr.Image(label="Performance Chart", type="pil")
-                    out_text_synth = gr.Textbox(label="Result", lines=20)
-
-            def synthetic_runner(size, op, repeats):
-                try:
-                    repeats = int(repeats)
-                    n_map = {"100k": 100000, "500k": 500000, "2M": 2000000}
-                    df = generate_data(n_map[size])
-                    result, meta = run_benchmark(op, df, repeats)
-                    chart = generate_chart(result)
-                    return chart, format_result(result, meta)
-                except Exception:
-                    return None, "Error:\n" + traceback.format_exc()
+
+        # ==================================================
+        # 🔥 Synthetic Mode
+        # ==================================================
+        with gr.Tab("🔥 Synthetic Dataset Benchmarks"):
+
+            dataset_size = gr.Radio(["100k", "500k", "2M"], value="100k", label="Dataset Size")
+
+            operation_synth = gr.Radio(
+                ["Filter", "Groupby", "Join", "Write Parquet"],
+                label="Operation",
+                value="Filter"
+            )
+
+            repeats_synth = gr.Slider(1, 7, value=3, label="Repeats")
+
+            btn_synth = gr.Button("🚀 Run Benchmark")
+
+            out_md_synth = gr.Markdown()
+            out_chart_synth = gr.Image()
+
+            def synthetic_runner(size, operation, repeats):
+                repeats = int(repeats)
+                n = {"100k": 100_000, "500k": 500_000, "2M": 2_000_000}[size]
+
+                df = generate_data(n)
+                result = run_benchmark(operation, df, repeats)
+                chart = generate_chart(result)
+
+                return format_result(result), chart
 
             btn_synth.click(
                 synthetic_runner,
                 [dataset_size, operation_synth, repeats_synth],
-                [out_chart_synth, out_text_synth],
+                [out_md_synth, out_chart_synth],
             )
 
-        with gr.Tab("Custom Dataset Upload"):
-            gr.Markdown(
-                "Your file must contain these columns: id, category, value1, value2, date"
+
+        # ==================================================
+        # 📁 Custom Dataset Mode
+        # ==================================================
+        with gr.Tab("📁 Custom Dataset Upload"):
+
+            file_in = gr.File(label="Upload CSV / Parquet / Arrow")
+            
+            operation_custom = gr.Radio(
+                ["Filter", "Groupby", "Join", "Write Parquet"],
+                label="Operation",
+                value="Filter"
             )
 
-            with gr.Row():
-                with gr.Column(scale=1):
-                    file_in = gr.File(label="Upload CSV / Parquet / Arrow")
-                    operation_custom = gr.Dropdown(
-                        choices=list(OPERATIONS.keys()),
-                        value="Filter (simple WHERE)",
-                        label="Operation",
-                    )
-                    repeats_custom = gr.Slider(
-                        1,
-                        7,
-                        value=3,
-                        step=1,
-                        label="Timing repeats",
-                    )
-                    btn_custom = gr.Button("Run Benchmark", variant="primary")
-
-                with gr.Column(scale=1):
-                    out_chart_custom = gr.Image(label="Performance Chart", type="pil")
-                    out_text_custom = gr.Textbox(label="Result", lines=20)
-
-            def custom_runner(file, op, repeats):
-                try:
-                    repeats = int(repeats)
-                    df = load_custom_dataset(file)
-                    required = {"id", "category", "value1", "value2", "date"}
-                    missing = required - set(df.columns)
-                    if missing:
-                        raise ValueError("Missing columns: " + str(sorted(missing)))
-                    result, meta = run_benchmark(op, df, repeats)
-                    chart = generate_chart(result)
-                    return chart, format_result(result, meta)
-                except Exception:
-                    return None, "Error:\n" + traceback.format_exc()
+            repeats_custom = gr.Slider(1, 7, value=3, label="Repeats")
+
+            btn_custom = gr.Button("Run on Uploaded Dataset")
+
+            out_md_custom = gr.Markdown()
+            out_chart_custom = gr.Image()
+
+            def custom_runner(file, operation, repeats):
+                repeats = int(repeats)
+                df = load_custom_dataset(file)
+                result = run_benchmark(operation, df, repeats)
+                return format_result(result), generate_chart(result)
 
             btn_custom.click(
                 custom_runner,
                 [file_in, operation_custom, repeats_custom],
-                [out_chart_custom, out_text_custom],
+                [out_md_custom, out_chart_custom],
             )
 
 if __name__ == "__main__":