Visualize: starter questions carry their plans (no planning call), hedged model calls so one slow provider can't stall a chart, sturdier label discovery, spread samples, whole-number histograms

app/visualize_api.py

@@ -45,6 +45,7 @@ class VisSet:
     created: float = field(default_factory=time.time)
     lock: threading.Lock = field(default_factory=threading.Lock)
     busy: bool = False
+    presets: dict = field(default_factory=dict)
 
 
 @dataclass
@@ -86,7 +87,7 @@ def _hub_rows(dataset: str, n: int) -> list[dict]:
     except Exception as e:
         raise HTTPException(400, f"Could not open {dataset}: {str(e)[:160]}")
     total = info.get("num_rows") or 0
-    chunks = 1 if not total or total <= n else min(4, math.ceil(n / 25))
+    chunks = 1 if not total or total <= n else min(4, max(3, math.ceil(n / 25)))  # sorted datasets need several slices
     per = math.ceil(n / chunks)
     starts = [0] if chunks == 1 else [max(0, int(total * (i + 0.5) / chunks) - per // 2) for i in range(chunks)]
     out, seen = [], set()
@@ -192,13 +193,13 @@ def load(body: LoadIn):
     if not cols:
         raise HTTPException(400, "None of the columns hold text, categories or numbers this can chart.")
     sid = uuid.uuid4().hex[:10]
-    vs = VisSet(id=sid, name=name, source=src, rows=rows, cols=cols)
+    vs = VisSet(id=sid, name=name, source=src, rows=rows, cols=cols, presets=V.presets(rows, cols))
     with GUARD:
         SETS[sid] = vs
         for old in sorted(SETS, key=lambda k: SETS[k].created)[:-30]:
             SETS.pop(old, None)
     return {"id": sid, "name": name, "source": src, "n": len(rows), "note": note, "columns": V.describe(rows, cols),
-            "glance": V.glance(rows, cols), "suggestions": V.suggestions(rows, cols), "rows": rows}
+            "glance": V.glance(rows, cols), "suggestions": list(vs.presets), "rows": rows}
 
 
 # ------------------------------------------------------------------ asking
@@ -228,14 +229,28 @@ def run_ask(a: Ask, vs: VisSet, ep):
         rows = [r for r in vs.rows if r["_id"] in ids] if ids else list(vs.rows)
         scope = f" (this question is about a selection of {len(rows)} of {len(vs.rows)} rows: {a.scope_label or 'chosen on a chart'})" if ids else ""
         plan, err = None, ""
-        for _ in range(2):
-            text = chat(V.plan_prompt(a.question, vs.name, rows, vs.cols, scope, err), max_tokens=700, temperature=0.2)
+        pre = vs.presets.get(a.question)
+        if pre:  # a starter question: its plan is already written, and labels found before are reused
+            plan = {**pre, "derive": [], "chart": dict(pre["chart"])}
+            for d in pre["derive"]:
+                c = vs.cols.get(d["name"])
+                if not (c and c.get("derived") == d["kind"] and c.get("from") == d["from"]):
+                    plan["derive"].append(dict(d))
+        def plan_once(temp):
+            text = chat(V.plan_prompt(a.question, vs.name, rows, vs.cols, scope, err), max_tokens=700, temperature=temp)
             try:
-                plan = V.parse_plan(text, vs.cols)
-                break
+                return V.parse_plan(text, vs.cols)
             except V.PlanError as e:
-                err = str(e)
-                print(f"[visualize] plan rejected: {err} | reply: {text[:600]!r}", flush=True)
+                errs.append(str(e))
+                print(f"[visualize] plan rejected: {e} | reply: {text[:600]!r}", flush=True)
+                return None
+
+        errs: list = []
+        for _ in range(0 if plan else 2):
+            plan = V.hedged(plan_once, tries=1)
+            if plan:
+                break
+            err = errs[-1] if errs else ""
         if not plan:
             plan = V.fallback_plan(a.question, rows, vs.cols)
         # new columns, plus earlier model-made columns this chart needs that do not cover these rows yet

datainventor/visualize.py

@@ -11,7 +11,8 @@ import json
 import math
 import re
 import statistics
-from concurrent.futures import ThreadPoolExecutor
+import time
+from concurrent.futures import FIRST_COMPLETED, ThreadPoolExecutor, wait
 from typing import Callable, Optional
 
 ID_NAMES = {"id", "_id", "idx", "index", "row_idx", "uuid", "row_id"}
@@ -23,6 +24,8 @@ LABEL_BATCH = 8
 MAX_GROUPS = 12           # categories on one axis before the rest fold into "Other"
 MAX_COLORS = 6
 KINDS = ("label", "score", "pattern", "count")
+HEDGE_AFTER = 8.0         # seconds before a slow call gets a twin; the first good answer wins
+_HEDGE = ThreadPoolExecutor(max_workers=24)
 CHARTS = ("bar", "stack", "box", "hist", "scatter")
 
 
@@ -404,30 +407,61 @@ def _pl(name: str) -> str:
     return name if name.endswith("s") else name + "s"
 
 
-def suggestions(rows: list[dict], cols: dict) -> list[str]:
+def presets(rows: list[dict], cols: dict) -> dict[str, dict]:
+    """Starter questions with their plans already written, so clicking one skips the planning call."""
     cat, ln = _main_cat(cols, rows), _main_len(cols)
     texts = [k for k, c in cols.items() if c["type"] == "text"]
     reply = next((k for k in ("completion", "chosen", "response", "output", "answer", "messages", "conversations") if k in texts), None)
     ask = next((k for k in ("prompt", "instruction", "question", "input", "query") if k in texts), None)
     other = next((k for k in texts if k not in (reply, ask)), None)
-    out = []
+    out: dict[str, dict] = {}
+
+    def add(q, title, spec, derive=(), ups=()):
+        known = dict(cols)
+        for d in derive:
+            known[d["name"]] = {"type": "num" if d["kind"] in ("score", "count") else "cat"}
+        try:
+            out[q] = {"title": title, "derive": [dict(d) for d in derive], "chart": check_spec(spec, known), "follow_ups": list(ups)}
+        except PlanError:
+            pass
+
     if reply:
-        out.append(f"What tone do the {_pl(reply)} take" + (f" in each {cat}?" if cat else "?"))
+        tone = {"name": "tone", "kind": "label", "from": reply, "guide": f"the overall tone of the {reply}",
+                "labels": ["friendly", "formal", "empathetic", "technical", "blunt"]}
+        add(f"What tone do the {_pl(reply)} take" + (f" in each {cat}?" if cat else "?"), f"Tone of the {_pl(reply)}" + (f" by {cat}" if cat else ""),
+            {"type": "stack", "x": cat, "color": "tone", "agg": "share"} if cat else {"type": "bar", "x": "tone"}, [tone],
+            [f"How long are the {_pl(reply)} for each tone?"] if ln else [])
     if ask:
-        out.append(f"What do the {_pl(ask)} ask for? Group them into a few themes.")
+        add(f"What do the {_pl(ask)} ask for? Group them into a few themes.", f"What the {_pl(ask)} ask for",
+            {"type": "bar", "x": "request"}, [{"name": "request", "kind": "label", "from": ask, "guide": f"what the {ask} asks for", "labels": []}])
     if not ask and not reply and other:
-        out.append(f"What themes come up in the {_pl(other)}?")
-        out.append(f"How positive or negative is each {other}?")
+        add(f"What themes come up in the {_pl(other)}?", f"Themes in the {_pl(other)}", {"type": "bar", "x": "theme"},
+            [{"name": "theme", "kind": "label", "from": other, "guide": f"the main theme of the {other}", "labels": []}])
+        add(f"How positive or negative is each {other}?", f"Sentiment of the {_pl(other)}", {"type": "hist", "x": "sentiment"},
+            [{"name": "sentiment", "kind": "score", "from": other, "guide": "1 = very negative, 3 = neutral or mixed, 5 = very positive"}])
     if ln and cat:
-        out.append(f"Which {cat} gets the longest {_pl(ln.replace(' words', ''))}?")
+        add(f"Which {cat} gets the longest {_pl(ln.replace(' words', ''))}?", f"{ln.replace(' words', '').capitalize()} length by {cat}",
+            {"type": "box", "x": cat, "y": ln})
     elif ln:
-        out.append(f"How long are the {_pl(ln.replace(' words', ''))}?")
+        add(f"How long are the {_pl(ln.replace(' words', ''))}?", f"{ln.capitalize()}", {"type": "hist", "x": ln})
     if reply:
-        out.append(f"How many {_pl(reply)} give step-by-step instructions?")
+        add(f"How many {_pl(reply)} give step-by-step instructions?", f"{_pl(reply).capitalize()} with step-by-step instructions",
+            {"type": "bar", "x": "gives steps"},
+            [{"name": "gives steps", "kind": "label", "from": reply, "guide": "whether it walks the reader through numbered or ordered steps",
+              "labels": ["yes", "no"]}])
     seconds = [k for k, c in cols.items() if c["type"] == "cat" and k != cat and 1 < len({r.get(k) for r in rows}) <= 8]
     if cat and seconds:
-        out.append(f"How does {seconds[0]} vary across {cat}?")
-    return out[:4]
+        add(f"How does {seconds[0]} vary across {cat}?", f"{seconds[0].capitalize()} within each {cat}",
+            {"type": "stack", "x": cat, "color": seconds[0], "agg": "share"})
+    return dict(list(out.items())[:4])
+
+
+def _pl(name: str) -> str:
+    return name if name.endswith("s") else name + "s"
+
+
+def suggestions(rows: list[dict], cols: dict) -> list[str]:
+    return list(presets(rows, cols))
 
 
 # ------------------------------------------------------------------ the model's part
@@ -632,6 +666,27 @@ def _read_labels(text: str, d: dict, k: int) -> Optional[dict]:
     return out if len(out) >= max(1, int(0.8 * k)) else None
 
 
+def hedged(fn: Callable[[float], object], after: float = HEDGE_AFTER, tries: int = 2):
+    """Call fn(temperature) and return its first truthy result. A call still running after `after`
+    seconds gets a twin, so one slow provider does not hold up the chart. None if every try fails."""
+    for attempt in range(tries):
+        futs = {_HEDGE.submit(fn, 0.1 if attempt == 0 else 0.4)}
+        start, twin = time.time(), False
+        while futs:
+            done, futs = wait(futs, timeout=None if twin else max(0.05, after - (time.time() - start)), return_when=FIRST_COMPLETED)
+            for f in done:
+                try:
+                    got = f.result()
+                except Exception:
+                    got = None
+                if got:
+                    return got
+            if not twin and (time.time() - start >= after or not futs):
+                futs = set(futs) | {_HEDGE.submit(fn, 0.5)}
+                twin = True
+    return None
+
+
 def fill(d: dict, rows: list[dict], chat: Callable[..., str], question: str = "",
          progress: Optional[Callable[[int], None]] = None, workers: int = 6) -> dict:
     """Compute one derived column for `rows`. Returns {row id: value} and may set d["labels"]."""
@@ -645,25 +700,26 @@ def fill(d: dict, rows: list[dict], chat: Callable[..., str], question: str = ""
             progress(len(rows))
         return vals
     if d["kind"] == "label" and len(d.get("labels") or []) < 2:
-        text = chat(discover_prompt(question, d, rows), max_tokens=200, temperature=0.3)
-        try:
-            labels = [str(x).strip().lower()[:40] for x in first_json(text) if str(x).strip()]
-        except (ValueError, TypeError):
-            labels = []
-        if len(labels) < 2:
-            raise PlanError(f'Could not find labels for "{d["name"]}".')
-        d["labels"] = list(dict.fromkeys(labels))[:7]
+        def discover(temp):
+            try:
+                obj = first_json(chat(discover_prompt(question, d, rows), max_tokens=200, temperature=temp + 0.2))
+            except ValueError:
+                return None
+            if isinstance(obj, dict):  # {"labels": [...]} and similar
+                obj = next((v for v in obj.values() if isinstance(v, list)), [])
+            labels = [str(x).strip().lower()[:40] for x in obj if isinstance(x, (str, int, float)) and str(x).strip()]
+            labels = list(dict.fromkeys(labels))[:7]
+            return labels if len(labels) >= 2 else None
+        labels = hedged(discover)
+        if not labels:
+            raise PlanError(f'Could not find labels for "{d["name"]}". Try asking again, or name the groups you expect.')
+        d["labels"] = labels
     batches = [rows[i:i + LABEL_BATCH] for i in range(0, len(rows), LABEL_BATCH)]
     vals: dict[int, object] = {}
     done = [0]
 
     def run(batch):
-        got = None
-        for attempt in range(3):
-            text = chat(label_prompt(d, batch), max_tokens=12 * len(batch) + 40, temperature=0.1 if attempt == 0 else 0.4)
-            got = _read_labels(text, d, len(batch))
-            if got:
-                break
+        got = hedged(lambda temp: _read_labels(chat(label_prompt(d, batch), max_tokens=12 * len(batch) + 40, temperature=temp), d, len(batch)))
         res = {}
         for k, r in enumerate(batch, 1):
             res[r["_id"]] = (got or {}).get(k, "unclear" if d["kind"] == "label" else None)