Create app.py

app.py

@@ -0,0 +1,274 @@
+import time
+import numpy as np
+import pandas as pd
+import duckdb
+import gradio as gr
+import matplotlib.pyplot as plt
+import io
+
+duckdb_con = duckdb.connect(database=":memory:")
+
+# ----------------------------------------------------------
+# Synthetic Data Generator
+# ----------------------------------------------------------
+
+def generate_data(n_rows: int, n_groups: int = 50) -> pd.DataFrame:
+    rng = np.random.default_rng(42)
+    ids = np.arange(n_rows)
+    categories = rng.integers(0, n_groups, size=n_rows)
+    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)
+    start_date = np.datetime64("2020-01-01")
+    dates = start_date + rng.integers(0, 365, size=n_rows).astype("timedelta64[D]")
+
+    return pd.DataFrame(
+        {"id": ids, "category": categories, "value1": value1, "value2": value2, "date": dates}
+    )
+
+
+# ----------------------------------------------------------
+# Timing utility
+# ----------------------------------------------------------
+
+def time_function(fn, repeats=3):
+    times = []
+    for _ in range(repeats):
+        start = time.perf_counter()
+        fn()
+        end = time.perf_counter()
+        times.append(end - start)
+    return np.mean(times), np.std(times), times
+
+
+# ----------------------------------------------------------
+# Benchmark Operations
+# ----------------------------------------------------------
+
+def bench_filter(df, repeats=3):
+    def pandas_op():
+        _ = df[(df["value1"] > 0.5) & (df["category"] == df["category"].iloc[0])]
+
+    def duckdb_op():
+        duckdb_con.register("df", df)
+        q = f"""
+        SELECT *
+        FROM df
+        WHERE value1 > 0.5
+        AND category = '{df['category'].iloc[0]}'
+        """
+        _ = duckdb_con.execute(q).fetchdf()
+
+    p_mean, p_std, p_all = time_function(pandas_op, repeats)
+    d_mean, d_std, d_all = time_function(duckdb_op, repeats)
+
+    return {
+        "operation": "Filter rows with comparison",
+        "pandas_mean_s": p_mean,
+        "pandas_std_s": p_std,
+        "duckdb_mean_s": d_mean,
+        "duckdb_std_s": d_std,
+        "speedup": p_mean / d_mean if d_mean > 0 else None,
+        "raw_pandas_runs": p_all,
+        "raw_duckdb_runs": d_all,
+    }
+
+
+def bench_groupby(df, repeats=3):
+    def pandas_op():
+        _ = df.groupby("category")[["value1", "value2"]].mean()
+
+    def duckdb_op():
+        duckdb_con.register("df", df)
+        _ = 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 {
+        "operation": "Groupby mean",
+        "pandas_mean_s": p_mean,
+        "pandas_std_s": p_std,
+        "duckdb_mean_s": d_mean,
+        "duckdb_std_s": d_std,
+        "speedup": p_mean / d_mean if d_mean > 0 else None,
+        "raw_pandas_runs": p_all,
+        "raw_duckdb_runs": d_all,
+    }
+
+
+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, len(categories))}
+    )
+
+    def pandas_op():
+        _ = df.merge(dim_df, on="category", how="left")
+
+    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()
+
+    p_mean, p_std, p_all = time_function(pandas_op, repeats)
+    d_mean, d_std, d_all = time_function(duckdb_op, repeats)
+
+    return {
+        "operation": "Left Join",
+        "pandas_mean_s": p_mean,
+        "pandas_std_s": p_std,
+        "duckdb_mean_s": d_mean,
+        "duckdb_std_s": d_std,
+        "speedup": p_mean / d_mean if d_mean > 0 else None,
+        "raw_pandas_runs": p_all,
+        "raw_duckdb_runs": d_all,
+    }
+
+
+# ----------------------------------------------------------
+# Benchmark Dispatcher
+# ----------------------------------------------------------
+
+def run_benchmark(operation, df, 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)
+    return None
+
+
+# ----------------------------------------------------------
+# Chart generator (NEW)
+# ----------------------------------------------------------
+
+def generate_chart(result):
+    fig, ax = plt.subplots(figsize=(4, 3))
+
+    engines = ["Pandas", "DuckDB"]
+    times = [result["pandas_mean_s"], result["duckdb_mean_s"]]
+
+    ax.bar(engines, times)
+    ax.set_ylabel("Time (seconds)")
+    ax.set_title("Pandas vs DuckDB Performance")
+
+    buf = io.BytesIO()
+    plt.tight_layout()
+    plt.savefig(buf, format="png")
+    buf.seek(0)
+    return buf
+
+
+# ----------------------------------------------------------
+# Formatting Results
+# ----------------------------------------------------------
+
+def format_result(result):
+    speed = result["speedup"]
+    verdict = (
+        f"🚀 **DuckDB is ~{speed:.2f}× faster**"
+        if speed > 1
+        else f"🐼 **Pandas is ~{1/speed:.2f}× faster**"
+    )
+
+    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
+
+
+# ----------------------------------------------------------
+# Gradio App
+# ----------------------------------------------------------
+
+theme = gr.themes.Soft(primary_hue="indigo", neutral_hue="slate")
+
+with gr.Blocks(title="DuckDB vs Pandas Benchmark", theme=theme) as demo:
+
+    gr.Markdown("# 🐼 vs 🦆 DuckDB vs Pandas Performance Playground")
+
+    with gr.Tabs():
+
+        # ---------------------- Synthetic Mode ----------------------
+        with gr.Tab("🔥 Synthetic Dataset Benchmarks"):
+            dataset_size = gr.Radio(["100k", "500k", "2M"], label="Dataset Size", value="100k")
+            operation_synth = gr.Radio(["Filter", "Groupby", "Join"], label="Operation")
+            repeats_synth = gr.Slider(1, 7, value=3, label="Repeats")
+            synth_btn = gr.Button("🚀 Run Benchmark")
+
+            synth_output = gr.Markdown()
+            synth_chart = gr.Image(label="Performance Chart")
+
+            def synthetic_runner(size, operation, 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
+
+            synth_btn.click(
+                synthetic_runner,
+                [dataset_size, operation_synth, repeats_synth],
+                [synth_output, synth_chart],
+            )
+
+        # ---------------------- Custom Dataset Mode ----------------------
+        with gr.Tab("📁 Custom Dataset Upload"):
+
+            file_input = gr.File(label="Upload a CSV / Parquet / Arrow file")
+            operation_custom = gr.Radio(["Filter", "Groupby", "Join"], label="Operation")
+            repeats_custom = gr.Slider(1, 7, value=3, label="Repeats")
+
+            custom_btn = gr.Button("Run on Uploaded Dataset")
+            custom_out = gr.Markdown()
+            custom_chart = gr.Image(label="Performance Chart")
+
+            def load_custom_dataset(file):
+                if file.name.endswith(".csv"):
+                    return pd.read_csv(file.name)
+                elif file.name.endswith(".parquet"):
+                    return pd.read_parquet(file.name)
+                elif file.name.endswith(".arrow"):
+                    return pd.read_feather(file.name)
+                else:
+                    raise ValueError("Unsupported format")
+
+            def custom_runner(file, operation, repeats):
+                df = load_custom_dataset(file)
+                result = run_benchmark(operation, df, repeats)
+                chart = generate_chart(result)
+                return format_result(result), chart
+
+            custom_btn.click(
+                custom_runner,
+                [file_input, operation_custom, repeats_custom],
+                [custom_out, custom_chart],
+            )
+
+
+if __name__ == "__main__":
+    demo.launch()