Update app.py

app.py

@@ -1,228 +1,91 @@
 #!/usr/bin/env python3
-"""
-what_comes_next.py – Hugging Face Space implementation of **What Comes Next**
-A global, slow-burn guessing game powered by Llama-3.1-8B-Instruct (FP32, CPU-only).
-
-HOW IT WORKS
-============
-• One shared model generates a single, very long completion (≈2 k tokens) for a chosen
-  prompt in *full precision* on CPU.  One token is sampled every ~15 s, so a prompt
-  unfolds for roughly 10 hours.  All visitors see the same progress in real-time.
-• Players read the partial output and may submit **either**
-    🧠 Exact continuation (full guess) **or** 💡 General idea (summary guess).
-• Each guess is appended to `data.json` with prompt, Oracle progress, timestamp & type.
-• Offline scoring (not included here) can later measure similarity vs the final text.
-"""
-
-from __future__ import annotations
-
-import os
-import json
-import time
-import random
-import threading
-import logging
-from datetime import datetime, timezone
-from typing import Dict, Any
+# what comes next sloppy version
 
-import torch
-import gradio as gr
+import os, json, time, random, threading, logging
+from datetime import datetime, timezone
+import torch, gradio as gr
 from transformers import AutoTokenizer, AutoModelForCausalLM
 
-###############################################################################
-# Configuration                                                                #
-###############################################################################
-MODEL_NAME           = "meta-llama/Llama-3.1-8B-Instruct"  # gated, requires HF_READ_TOKEN
-PROMPTS_PATH         = "full_prompts.json"                 # 100 full prompts
-STATE_PATH           = "current_state.json"                # persistent Oracle state
-DATA_PATH            = "data.json"                         # JSONL log of guesses
-
-TOKENS_PER_PROMPT    = 2048        # stop after N generated tokens
-SECS_BETWEEN_TOKENS  = 15          # ~10 h per prompt
-TEMPERATURE          = 0.9         # higher creativity, as requested
-TOP_P                = 0.95        # nucleus sampling
-MAX_CONTEXT_TOKENS   = 8192        # safety cap
-###############################################################################
-
-logging.basicConfig(format="[%(asctime)s] %(levelname)s: %(message)s", level=logging.INFO)
-log = logging.getLogger("what-comes-next")
-
-###############################################################################
-# Utility helpers                                                              #
-###############################################################################
-
-def _read_json(path: str, default: Any):
-    try:
-        with open(path, "r", encoding="utf-8") as f:
-            return json.load(f)
-    except FileNotFoundError:
-        return default
-
-
-def _atomic_write(path: str, obj: Any):
-    tmp = f"{path}.tmp"
-    with open(tmp, "w", encoding="utf-8") as f:
-        json.dump(obj, f, ensure_ascii=False, indent=2)
-    os.replace(tmp, path)
-
-
-def load_prompts() -> list[str]:
-    if not os.path.exists(PROMPTS_PATH):
-        raise FileNotFoundError(f"Missing {PROMPTS_PATH}. Please add 100 prompts.")
-    with open(PROMPTS_PATH, "r", encoding="utf-8") as f:
-        prompts = json.load(f)
-    if not isinstance(prompts, list) or not prompts:
-        raise ValueError("full_prompts.json must be a non-empty JSON array of strings")
-    return prompts
-
-###############################################################################
-# Model loading                                                                #
-###############################################################################
-log.info("Loading Llama-3.1-8B-Instruct (FP32 CPU-only) using secret token…")
-
-tokenizer = AutoTokenizer.from_pretrained(
-    MODEL_NAME,
-    use_auth_token=os.environ.get("HF_READ_TOKEN")
-)
-model = AutoModelForCausalLM.from_pretrained(
-    MODEL_NAME,
-    torch_dtype=torch.float32,
-    device_map={"": "cpu"},
-    use_auth_token=os.environ.get("HF_READ_TOKEN")
-)
-model.eval()
-log.info("Model ready – Oracle awakened.")
-
-###############################################################################
-# Global state                                                                 #
-###############################################################################
-lock = threading.Lock()          # guard state + files
-prompts = load_prompts()         # list of 100 strings
-
-###############################################################################
-# Oracle generation thread                                                     #
-###############################################################################
-
-def _init_state() -> Dict[str, Any]:
-    """Return existing state or create a fresh one if none/finished."""
-    state = _read_json(STATE_PATH, {})
-    if not state or state.get("finished"):
-        prompt_idx = random.randrange(len(prompts))
-        state = {
-            "prompt_idx": prompt_idx,
-            "prompt": prompts[prompt_idx],
-            "generated": "",          # text so far
-            "tokens_done": 0,
-            "start_time": time.time(),
-            "finished": False
-        }
-        _atomic_write(STATE_PATH, state)
-        log.info(f"New Oracle prompt #{prompt_idx}: {state['prompt'][:80]}…")
-    return state
-
-
-def _elapsed_str(start: float) -> str:
-    d = int(time.time() - start)
-    h, r = divmod(d, 3600)
-    m, s = divmod(r, 60)
-    return f"{h}h {m}m {s}s"
-
+MODEL_NAME = "meta-llama/Llama-3.1-8B-Instruct"
+PROMPTS_PATH = "full_prompts.json"
+STATE_PATH = "current_state.json"
+DATA_PATH = "data.json"
+TOKENS_PER_PROMPT = 2048
+SECS_BETWEEN_TOKENS = 15
+TEMPERATURE = 0.9
+TOP_P = 0.95
+MAX_CONTEXT_TOKENS = 8192
+
+logging.basicConfig(level=logging.INFO)
+log = logging.getLogger()
+
+def _read_json(p, d):
+    try: return json.load(open(p, encoding="utf-8"))
+    except: return d
+
+def _atomic_write(p, o):
+    t = p + ".tmp"; open(t, "w", encoding="utf-8").write(json.dumps(o, ensure_ascii=False, indent=2)); os.replace(t,p)
+
+def load_prompts():
+    l = _read_json(PROMPTS_PATH, [])
+    if not l: raise FileNotFoundError
+    return l
+
+# load model (uses HF_READ_TOKEN)
+tok = os.environ.get("HF_READ_TOKEN")
+tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME, token=tok)
+model = AutoModelForCausalLM.from_pretrained(MODEL_NAME, torch_dtype=torch.float32, low_cpu_mem_usage=True, token=tok)
+model.to(torch.device("cpu")); model.eval()
+
+prompts = load_prompts(); lock = threading.Lock()
+
+# main loop: oracle gen
+def _init_state():
+    s = _read_json(STATE_PATH, {})
+    if not s or s.get("finished"):
+        i = random.randrange(len(prompts))
+        s = {"prompt_idx":i, "prompt":prompts[i], "generated":"", "tokens_done":0, "start_time":time.time(), "finished":False}
+        _atomic_write(STATE_PATH, s)
+    return s
+
+def _elapsed_str(st):
+    d=int(time.time()-st);h,r=divmod(d,3600);m,s=divmod(r,60);return f"{h}h {m}m {s}s"
 
 def oracle_loop():
     while True:
+        with lock: s=_init_state()
+        if s["finished"]: time.sleep(SECS_BETWEEN_TOKENS); continue
+        c=s["prompt"]+s["generated"]
+        ids=tokenizer(c, return_tensors="pt", truncation=True, max_length=MAX_CONTEXT_TOKENS).input_ids
+        with torch.no_grad(): out=model.generate(ids, max_new_tokens=1, do_sample=True, temperature=TEMPERATURE, top_p=TOP_P)
+        nt=tokenizer.decode(out[0,-1], skip_special_tokens=True, clean_up_tokenization_spaces=False)
         with lock:
-            state = _init_state()
-        if state["finished"]:
-            time.sleep(SECS_BETWEEN_TOKENS)
-            continue
-
-        # Build context: prompt + generated so far
-        context = state["prompt"] + state["generated"]
-        input_ids = tokenizer(context, return_tensors="pt", truncation=True, max_length=MAX_CONTEXT_TOKENS).input_ids
-
-        # Sample one token
-        with torch.no_grad():
-            out = model.generate(
-                input_ids,
-                max_new_tokens=1,
-                do_sample=True,
-                temperature=TEMPERATURE,
-                top_p=TOP_P,
-            )
-        next_token = tokenizer.decode(out[0, -1], skip_special_tokens=True, clean_up_tokenization_spaces=False)
-
-        with lock:
-            state["generated"] += next_token
-            state["tokens_done"] += 1
-            if state["tokens_done"] >= TOKENS_PER_PROMPT:
-                state["finished"] = True
-                log.info("Prompt completed – Oracle will select a new one shortly.")
-            _atomic_write(STATE_PATH, state)
+            s["generated"]+=nt; s["tokens_done"]+=1
+            if s["tokens_done"]>=TOKENS_PER_PROMPT: s["finished"]=True
+            _atomic_write(STATE_PATH, s)
         time.sleep(SECS_BETWEEN_TOKENS)
-
 threading.Thread(target=oracle_loop, daemon=True).start()
 
-###############################################################################
-# Gradio interface                                                             #
-###############################################################################
-
-def fetch_state() -> tuple[str, str, str]:
-    state = _read_json(STATE_PATH, {})
-    if not state:
-        return "Loading…", "", "0h 0m 0s"
-    return state["prompt"], state["generated"], _elapsed_str(state["start_time"])
-
-
-def submit_guess(full: str, idea: str):
-    full = full.strip()
-    idea = idea.strip()
-    if not full and not idea:
-        return gr.update(value="⚠️ Enter a guess in one of the fields."), gr.update(), gr.update()
-
-    prompt, generated, elapsed = fetch_state()
-    guess_text = full or idea
-    guess_type = "full" if full else "idea"
-
-    record = {
-        "timestamp": datetime.now(timezone.utc).isoformat(),
-        "prompt": prompt,
-        "point-in-time": elapsed,
-        "response-point": generated,
-        "user-guess": guess_text,
-        "guess-type": guess_type
-    }
-    with lock:
-        with open(DATA_PATH, "a", encoding="utf-8") as f:
-            f.write(json.dumps(record, ensure_ascii=False) + "\n")
-    log.info(f"Logged {guess_type} guess ({len(guess_text)} chars).")
-    return gr.update(value="✅ Guess recorded – thanks!"), gr.update(value=""), gr.update(value="")
-
-
-with gr.Blocks(title="What Comes Next", theme="gradio/soft") as demo:
-    gr.Markdown("""# 🌌 What Comes Next
-Watch the Oracle craft an extended response – **one token at a time**. Predict its
-next words or general direction and see how close you were when the tale concludes.
-(All inputs are stored in `data.json` for research.)""")
-
-    prompt_md   = gr.Markdown()
-    oracle_box  = gr.Textbox(lines=10, interactive=False, label="📜 Oracle text so far")
-    elapsed_tb  = gr.Textbox(interactive=False, label="⏱ Elapsed time")
-
-    refresh_btn = gr.Button("🔄 Refresh")
-
-    with gr.Row():
-        exact_tb = gr.Textbox(label="🧠 Exact continuation (full)")
-        idea_tb  = gr.Textbox(label="💡 General idea")
-    submit_btn  = gr.Button("Submit Guess")
-    status_tb   = gr.Textbox(interactive=False, label="Status")
-
-    # Actions
-    refresh_btn.click(fetch_state, outputs=[prompt_md, oracle_box, elapsed_tb])
-    demo.load(fetch_state, outputs=[prompt_md, oracle_box, elapsed_tb])
-
-    submit_btn.click(submit_guess,
-                     inputs=[exact_tb, idea_tb],
-                     outputs=[status_tb, exact_tb, idea_tb])
-
-if __name__ == "__main__":
-    demo.launch(server_name="0.0.0.0", server_port=7860, show_error=True)
+# ui
+
+def fetch_state():
+    s=_read_json(STATE_PATH,{})
+    if not s: return "Loading...","","0h 0m 0s"
+    return s["prompt"], s["generated"], _elapsed_str(s["start_time"])
+
+def submit_guess(full, idea):
+    f=full.strip(); i=idea.strip()
+    if not (f or i): return gr.update(value="enter guess!"),gr.update(),gr.update()
+    p,g,e=fetch_state(); guess=f or i; gt="full" if f else "idea"
+    r={"timestamp":datetime.now(timezone.utc).isoformat(),"prompt":p,"point-in-time":e,"response-point":g,"user-guess":guess,"guess-type":gt}
+    with lock: open(DATA_PATH,"a",encoding="utf-8").write(json.dumps(r,ensure_ascii=False)+"\n")
+    return gr.update(value="logged!"),gr.update(value=""),gr.update(value="")
+
+with gr.Blocks(title="What Comes Next") as demo:
+    gr.Markdown("# What Comes Next - sloppy")
+    prm=gr.Markdown(); txt=gr.Textbox(lines=10,interactive=False,label="oracle"); elt=gr.Textbox(interactive=False,label="time")
+    r=gr.Button("refresh"); f=gr.Textbox(label="full guess"); i=gr.Textbox(label="idea"); sbtn=gr.Button("send"); st=gr.Textbox(interactive=False,label="st")
+    demo.load(fetch_state,outputs=[prm,txt,elt])
+    r.click(fetch_state,outputs=[prm,txt,elt]); sbtn.click(submit_guess,inputs=[f,i],outputs=[st,f,i])
+
+if __name__=="__main__": demo.launch(server_name="0.0.0.0",server_port=7860)