Update app.py

app.py

@@ -1,6 +1,5 @@
 """
-🌐  What-If Lab — live 2×2 scenario mapper (MCP-enabled)
-Harsha Angeri / ChatGPT helper • MIT
+What-If Lab – live 2×2 scenario mapper (MCP-enabled, fully patched for Spaces)
 """
 
 import io, os, time, uuid, threading, hashlib, warnings
@@ -18,143 +17,138 @@ try:
     import openai
 except ImportError:
     openai = None
-    warnings.warn("`openai` package not found; embeddings disabled")
+    warnings.warn("`openai` package not found; OpenAI clustering disabled")
 
-# ───────────────────────── helpers ──────────────────────────
-def utc() -> str:
+# Helpers
+def utc_ts() -> str:
     return datetime.utcnow().strftime("%H:%M:%S")
 
-def log(txt: str):
-    print(f"[{utc()}] {txt}", flush=True)
+def log(msg: str):
+    print(f"[{utc_ts()}] {msg}", flush=True)
 
-def web_search(q: str, k: int = 20) -> list[str]:
-    with DDGS() as dd:
-        return [f"{r['title']} – {r.get('body','')}" for r in dd.text(q, max_results=k)]
+def search_web(query: str, k: int = 20) -> list[str]:
+    with DDGS() as ddgs:
+        return [f"{r['title']} – {r.get('body','')}" for r in ddgs.text(query, max_results=k)]
 
-def hash_xy(txt: str):
-    h = int(hashlib.sha256(txt.encode()).hexdigest(), 16)
+def deterministic_xy(text: str):
+    h = int(hashlib.sha256(text.encode()).hexdigest(), 16)
     return ((h % 1000) / 500 - 1, ((h >> 10) % 1000) / 500 - 1)
 
-def embed(txts: list[str], key: str):
+def embed_texts(texts: list[str], key: str):
     if openai is None:
-        raise RuntimeError("install `openai` for embeddings")
+        raise RuntimeError("`openai` not installed")
     if not key:
         raise RuntimeError("OpenAI key missing")
     openai.api_key = key
-    res = openai.embeddings.create(model="text-embedding-3-small", input=txts)
+    res = openai.embeddings.create(model="text-embedding-3-small", input=texts)
     return np.array([d.embedding for d in res.data])
 
-def cluster(snips, embeds):
+def cluster_points(snips: list[str], embeds):
     if embeds is None:
-        return [(*hash_xy(s), s[:50] + ("…" if len(s) > 50 else "")) for s in snips[:16]]
+        return [(*deterministic_xy(s), s[:50] + ("…" if len(s) > 50 else "")) for s in snips[:16]]
 
     k = min(max(len(snips) // 5, 4), 12)
-    km   = KMeans(n_clusters=k, n_init="auto", random_state=0).fit(embeds)
-    pca2 = PCA(n_components=2, random_state=0).fit_transform(km.cluster_centers_)
-
-    labels = [snips[int(np.argmin(np.linalg.norm(embeds - c, axis=1)))][:50] + "…"
-              for c in km.cluster_centers_]
-
-    xs, ys = pca2[:, 0], pca2[:, 1]
+    km = KMeans(n_clusters=k, n_init="auto", random_state=0).fit(embeds)
+    pca2d = PCA(n_components=2, random_state=0).fit_transform(km.cluster_centers_)
+    labels = []
+    for c in km.cluster_centers_:
+        labels.append(snips[int(np.argmin(np.linalg.norm(embeds - c, axis=1)))][:50] + "…")
+    xs, ys = pca2d[:, 0], pca2d[:, 1]
     xs = (xs - xs.min()) / (np.ptp(xs) + 1e-4) * 2 - 1
     ys = (ys - ys.min()) / (np.ptp(ys) + 1e-4) * 2 - 1
     return list(zip(xs, ys, labels))
 
-def make_plot(points, ax1, ax2):
+def draw_plot(points, ax1, ax2):
     fig, ax = plt.subplots(figsize=(5, 5))
-    ax.axhline(0, color="black", lw=0.8); ax.axvline(0, color="black", lw=0.8)
+    ax.axhline(0, color="black", lw=0.8)
+    ax.axvline(0, color="black", lw=0.8)
     ax.set_xlim(-1.1, 1.1); ax.set_ylim(-1.1, 1.1)
     ax.set_xlabel(ax1, fontsize=12, fontweight="bold")
     ax.set_ylabel(ax2, fontsize=12, fontweight="bold")
-    for x, y, label in points:
-        ax.scatter(x, y, s=40); ax.text(x, y, label, fontsize=8, ha="left", va="bottom")
+    for x, y, lbl in points:
+        ax.scatter(x, y, s=40); ax.text(x, y, lbl, fontsize=8, ha="left", va="bottom")
     buf = io.BytesIO(); fig.tight_layout(); fig.savefig(buf, format="png"); plt.close(fig)
     buf.seek(0)
-    return PILImage.open(buf)
+    return PILImage.open(buf)   # <-- return PIL.Image object
 
-# ─────────────────── session store & worker ──────────────────
+# Session store & worker
 LABS = {}
 
 def worker(sid):
-    cfg = LABS[sid]
-    a1, a2, refresh, key = cfg["axis1"], cfg["axis2"], cfg["refresh"], cfg["key"]
-    log(f"Worker started {sid}")
+    cfg = LABS[sid]; a1, a2, ref, key = cfg["axis1"], cfg["axis2"], cfg["refresh"], cfg["key"]
+    log(f"Worker started for {sid}")
     while cfg["running"]:
         t0 = time.perf_counter()
         try:
-            snips = web_search(f"{a1} {a2}", 20)
-            cfg["logs"].append(f"[{utc()}] {len(snips)} signals")
+            snips = search_web(f"{a1} {a2}", 20); cfg["logs"].append(f"[{utc_ts()}] {len(snips)} signals")
         except Exception as e:
-            cfg["logs"].append(f"[{utc()}] Search ERROR: {e}"); time.sleep(refresh); continue
+            cfg["logs"].append(f"[{utc_ts()}] Search ERROR: {e}"); time.sleep(ref); continue
         try:
-            embeds = embed(snips, key) if key else None
+            embeds = embed_texts(snips, key) if key else None
         except Exception as e:
-            cfg["logs"].append(f"[{utc()}] Embed fallback: {e}"); embeds = None
+            cfg["logs"].append(f"[{utc_ts()}] Embed fallback: {e}"); embeds = None
         try:
-            cfg["points"] = cluster(snips, embeds)
-            cfg["logs"].append(f"[{utc()}] Plot with {len(cfg['points'])} pts")
+            cfg["points"] = cluster_points(snips, embeds)
+            cfg["logs"].append(f"[{utc_ts()}] Plot with {len(cfg['points'])} pts")
         except Exception as e:
-            cfg["logs"].append(f"[{utc()}] Cluster ERROR: {e}")
-        time.sleep(max(refresh - (time.perf_counter() - t0), 0.3))
-    log(f"Worker stopped {sid}")
+            cfg["logs"].append(f"[{utc_ts()}] Cluster ERROR: {e}")
+        time.sleep(max(ref - (time.perf_counter() - t0), 0.2))
+    log(f"Worker stopped for {sid}")
 
-# ─────────────────────── MCP endpoints ───────────────────────
+# MCP-exposed endpoints
 def scenario_lab(axis1, axis2, refresh=20, openai_key=None):
     axis1, axis2 = axis1.strip(), axis2.strip()
     if len(axis1) < 3 or len(axis2) < 3:
-        raise gr.Error("Axis prompts must be ≥3 chars")
+        raise gr.Error("Axis prompts must be ≥3 chars.")
     sid = str(uuid.uuid4())
-    LABS[sid] = dict(
-        axis1=axis1.title(), axis2=axis2.title(),
-        refresh=max(5, int(refresh)), key=openai_key or os.getenv("OPENAI_API_KEY", ""),
-        points=[], logs=[f"[{utc()}] Session created"], running=True
-    )
+    LABS[sid] = dict(axis1=axis1.title(), axis2=axis2.title(),
+                     refresh=max(5, int(refresh)), key=openai_key or os.getenv("OPENAI_API_KEY",""),
+                     points=[], logs=[f"[{utc_ts()}] Session created"], running=True)
     threading.Thread(target=worker, args=(sid,), daemon=True).start()
-    log(f"Created {sid}")
+    log(f"Created session {sid}")
     return {"session_id": sid}
 
 def get_plot(session_id):
     cfg = LABS.get(session_id) or gr.Error("Unknown session_id")
-    return make_plot(cfg["points"], cfg["axis1"], cfg["axis2"]) if cfg["points"] else \
-           make_plot([], cfg["axis1"], cfg["axis2"])
+    if not cfg["points"]:
+        return draw_plot([], cfg["axis1"], cfg["axis2"])
+    return draw_plot(cfg["points"], cfg["axis1"], cfg["axis2"])
 
 def get_logs(session_id):
     cfg = LABS.get(session_id) or gr.Error("Unknown session_id")
     return cfg["logs"][-40:]
 
-# ─────────────────────────── UI ──────────────────────────────
+# Gradio UI
 with gr.Blocks(title="🌐 What-If Lab") as demo:
-    gr.Markdown("## 🌐 What-If Lab — live 2×2 scenario mapper")
+    gr.Markdown("## 🌐 What-If Lab – live scenario 2×2")
     with gr.Row():
-        in_a1 = gr.Textbox(label="Axis A"); in_a2 = gr.Textbox(label="Axis B")
+        a1 = gr.Textbox(label="Axis A"); a2 = gr.Textbox(label="Axis B")
     with gr.Row():
-        in_ref = gr.Slider(5, 60, value=20, step=1, label="Refresh (s)")
-        in_key = gr.Textbox(label="OpenAI key (opt.)", type="password")
-        btn    = gr.Button("🚀 Run")
-    out_img = gr.Image(label="Live 2×2", height=400)
-    out_log = gr.Textbox(label="Log", lines=20, interactive=False)
-    sid     = gr.State("")
-
-    # launch session
-    btn.click(lambda a,b,r,k: scenario_lab(a,b,r,k)["session_id"],
-              inputs=[in_a1, in_a2, in_ref, in_key],
-              outputs=sid)
-
-    # polling callback
-    def ui_poll(s):
-        if not s: return gr.update(), gr.update()
+        ref = gr.Slider(5, 60, value=20, step=1, label="Refresh (s)")
+        key = gr.Textbox(label="OpenAI key (opt.)", type="password"); run = gr.Button("🚀 Run")
+    img = gr.Image(label="Live 2×2", height=400); log_box = gr.Textbox(label="Log", lines=20, interactive=False)
+    sid_state = gr.State("")
+
+    def ui_launch(x, y, r, k): return scenario_lab(x, y, r, k)["session_id"]
+    run.click(ui_launch, [a1, a2, ref, key], sid_state)
+
+    def ui_poll(sid):
+        if not sid: return gr.update(), gr.update()
         try:
-            return gr.update(value=get_plot(s)), gr.update(value="\n".join(get_logs(s)))
+            return gr.update(value=get_plot(sid)), gr.update(value="\n".join(get_logs(sid)))
         except Exception as e:
             return gr.update(), gr.update(value=f"Error: {e}")
 
-    # first load
-    demo.load(ui_poll, inputs=[sid], outputs=[out_img, out_log])
+    demo.load(ui_poll, [sid_state], [img, log_box])
 
-    # 3-second timer (new API)
-    timer = gr.Timer(3)  
-    timer.then(ui_poll, inputs=[sid], outputs=[out_img, out_log])
+    # ✅ FIXED: new Timer syntax for Gradio 4.21+
+    gr.Timer(
+        fn=ui_poll,
+        every=30,
+        inputs=[sid_state],
+        outputs=[img, log_box]
+    )
 
-# ─────────────────────���─── launch ────────────────────────────
+# Launch (UI + MCP)
 if __name__ == "__main__":
     demo.launch(show_api=True, mcp_server=True, share=True)