Upload app.py with huggingface_hub

app.py

@@ -1,13 +1,11 @@
-
 import json, math, torch, gradio as gr
 from collections import Counter
 import numpy as np
 from huggingface_hub import hf_hub_download
 import torch.nn as nn
 
-REPO_ID = "sato2ru/wordle-solver"  # ← update this
+REPO_ID = "sato2ru/wordle-solver"
 
-# ── Load assets from HF Hub ──────────────────────────────────────
 config  = json.load(open(hf_hub_download(REPO_ID, "config.json")))
 ANSWERS = json.load(open(hf_hub_download(REPO_ID, "answers.json")))
 ALLOWED = json.load(open(hf_hub_download(REPO_ID, "allowed.json")))
@@ -19,7 +17,6 @@ OUTPUT_DIM = config["output_dim"]
 OPENING    = config["opening_guess"]
 WIN_PATTERN = (2,2,2,2,2)
 
-# ── Model ────────────────────────────────────────────────────────
 class WordleNet(nn.Module):
     def __init__(self):
         super().__init__()
@@ -36,15 +33,17 @@ model = WordleNet()
 model.load_state_dict(torch.load(hf_hub_download(REPO_ID, "model_weights.pt"), map_location="cpu"))
 model.eval()
 
-# ── Helpers ──────────────────────────────────────────────────────
 def get_pattern(guess, answer):
     pattern = [0]*5
     counts = Counter(answer)
     for i in range(5):
-        if guess[i] == answer[i]: pattern[i] = 2; counts[guess[i]] -= 1
+        if guess[i] == answer[i]:
+            pattern[i] = 2
+            counts[guess[i]] -= 1
     for i in range(5):
-        if pattern[i] == 0 and counts.get(guess[i],0) > 0:
-            pattern[i] = 1; counts[guess[i]] -= 1
+        if pattern[i] == 0 and counts.get(guess[i], 0) > 0:
+            pattern[i] = 1
+            counts[guess[i]] -= 1
     return tuple(pattern)
 
 def filter_words(words, guess, pattern):
@@ -63,26 +62,23 @@ def encode_board(history):
     return vec
 
 def model_suggest(history, possible):
-    if len(possible) == 1: return possible[0]
-    if not history:         return OPENING
+    if len(possible) == 1:
+        return possible[0]
+    if not history:
+        return OPENING
     state = torch.tensor(encode_board(history)).unsqueeze(0)
     with torch.no_grad():
         logits = model(state)[0]
     top5 = [ALLOWED[i] for i in logits.topk(5).indices.tolist()]
     return max(top5, key=lambda w: entropy_score(w, possible))
 
-# ── State ─────────────────────────────────────────────────────────
-def init_state():
-    return {"possible": list(ANSWERS), "history": [], "done": False}
-
 def render_board(history):
     colours = {0: "⬜", 1: "🟨", 2: "🟩"}
     rows = []
     for word, pattern in history:
-        tiles = " ".join(f"{colours[s]}{c.upper()}" for c, s in zip(word, pattern))
+        tiles = "  ".join(colours[s] + c.upper() for c, s in zip(word, pattern))
         rows.append(tiles)
-    return "
-".join(rows) if rows else "(no guesses yet)"
+    return "\n".join(rows) if rows else "(no guesses yet)"
 
 def process_guess(guess_input, pattern_input, state):
     if state["done"]:
@@ -90,50 +86,53 @@ def process_guess(guess_input, pattern_input, state):
 
     guess = guess_input.strip().lower()
     if len(guess) != 5:
-        return render_board(state["history"]), "⚠️ Guess must be 5 letters", state
+        return render_board(state["history"]), "Word must be 5 letters", state
     if len(pattern_input) != 5 or not all(c in "012" for c in pattern_input):
-        return render_board(state["history"]), "⚠️ Pattern must be 5 digits (0/1/2)", state
+        return render_board(state["history"]), "Pattern must be 5 digits (0/1/2)", state
 
     pattern = tuple(int(c) for c in pattern_input)
     state["history"].append((guess, pattern))
 
     if pattern == WIN_PATTERN:
         state["done"] = True
-        msg = f"🎉 Solved in {len(state["history"])} turns!"
-        return render_board(state["history"]), msg, state
+        turns = len(state["history"])
+        return render_board(state["history"]), f"Solved in {turns} turns!", state
 
     state["possible"] = filter_words(state["possible"], guess, pattern)
+
     if not state["possible"]:
         state["done"] = True
-        return render_board(state["history"]), "❌ No words left. Check your input.", state
+        return render_board(state["history"]), "No words left. Check your input.", state
 
     suggestion = model_suggest(state["history"], state["possible"])
-    msg = f"Try: **{suggestion.upper()}**  |  {len(state["possible"])} words left"
+    remaining = len(state["possible"])
+    msg = f"Try: {suggestion.upper()}  |  {remaining} words remaining"
     return render_board(state["history"]), msg, state
 
-def reset(_state):
-    s = init_state()
-    return render_board([]), f"Try: **{OPENING.upper()}** to start", s
+def reset_game(state):
+    new_state = {"possible": list(ANSWERS), "history": [], "done": False}
+    return render_board([]), f"Try: {OPENING.upper()} to start", new_state
+
+def init_state():
+    return {"possible": list(ANSWERS), "history": [], "done": False}
 
-# ── Gradio UI ─────────────────────────────────────────────────────
 with gr.Blocks(title="Wordle Solver", theme=gr.themes.Monochrome()) as demo:
-    gr.Markdown("# 🟩 Wordle Solver
-Entropy-trained neural network. Enter each guess + the colour pattern.")
-    gr.Markdown("**Pattern key:** `0` = ⬜ grey · `1` = 🟨 yellow · `2` = 🟩 green")
+    gr.Markdown("# Wordle Solver")
+    gr.Markdown("Enter each guess and the colour pattern. **0** = grey  **1** = yellow  **2** = green")
 
-    state = gr.State(init_state())
-    board_out = gr.Textbox(label="Board", lines=7, interactive=False)
-    msg_out   = gr.Markdown(f"Try: **{OPENING.upper()}** to start")
+    state    = gr.State(init_state())
+    board    = gr.Textbox(label="Board", lines=8, interactive=False)
+    message  = gr.Markdown(f"Try: **{OPENING.upper()}** to start")
 
     with gr.Row():
-        guess_in   = gr.Textbox(label="Your guess",   placeholder="crane", max_lines=1)
-        pattern_in = gr.Textbox(label="Pattern (5 digits)", placeholder="02100", max_lines=1)
+        guess_box   = gr.Textbox(label="Your guess", placeholder="crane", max_lines=1)
+        pattern_box = gr.Textbox(label="Pattern", placeholder="00000", max_lines=1)
 
     with gr.Row():
-        submit_btn = gr.Button("Submit",  variant="primary")
+        submit_btn = gr.Button("Submit", variant="primary")
         reset_btn  = gr.Button("Reset")
 
-    submit_btn.click(process_guess, [guess_in, pattern_in, state], [board_out, msg_out, state])
-    reset_btn.click(reset, [state], [board_out, msg_out, state])
+    submit_btn.click(process_guess, [guess_box, pattern_box, state], [board, message, state])
+    reset_btn.click(reset_game, [state], [board, message, state])
 
 demo.launch()