mimicking to imitate the same in github

app.py

@@ -1,36 +1,204 @@
 # app.py
+# CLI-like Spelling Bee Tutor as a simple Gradio UI (no LLMs, all offline)
 import gradio as gr
 import pandas as pd
 from pathlib import Path
 
 WORDS_PATH = Path("words.csv")
 
-def lookup(prefix: str):
+def _load_words():
+    """Load CSV; ensure we have a 'word' column; create optional columns if missing.
+    Also compute a difficulty score (fallback = word length)."""
     if not WORDS_PATH.exists():
-        return "words.csv not found in repo."
+        # return empty df with expected columns
+        return pd.DataFrame(columns=["word", "definition", "origin", "sentence", "difficulty_score"])
+
+    df = pd.read_csv(WORDS_PATH)
+
+    # normalize required/optional columns
+    if "word" not in df.columns:
+        # treat first column as 'word'
+        df = df.rename(columns={df.columns[0]: "word"})
+
+    for col in ["definition", "origin", "sentence"]:
+        if col not in df.columns:
+            df[col] = ""
+
+    # difficulty: use numeric 'difficulty' if present; else use length
+    if "difficulty" in df.columns:
+        ds = pd.to_numeric(df["difficulty"], errors="coerce").fillna(0)
+        df["difficulty_score"] = ds
+    else:
+        df["difficulty_score"] = df["word"].astype(str).str.len()
+
+    # sort hardest -> easiest
+    df = df.sort_values("difficulty_score", ascending=False).reset_index(drop=True)
+    return df
+
+DF = _load_words()
+
+def _summary(state):
+    if not state:
+        return "No round active."
+    n = state["n"]
+    score = state["score"]
+    return f"Round complete. Score this round: {score}/{n}."
+
+def start_quiz(n_words, state):
+    df = DF
+    if df.empty:
+        # disable input if no words
+        return (state,
+                "words.csv not found or empty.",
+                gr.update(value="", interactive=False),
+                "Please add a words.csv with at least one 'word' column.",
+                "Score: 0/0",
+                gr.update(value="", interactive=False))
+
     try:
-        df = pd.read_csv(WORDS_PATH)
-    except Exception as e:
-        return f"Failed to read words.csv: {e}"
+        n = int(n_words or 5)
+    except Exception:
+        n = 5
+
+    # clip to available size
+    n = max(1, min(n, len(df)))
+
+    # take top-n hardest words
+    block = df.head(n).reset_index(drop=True)
+
+    s = {
+        "i": 0,
+        "n": n,
+        "score": 0,
+        "words": block["word"].astype(str).tolist(),
+        "defs": block["definition"].astype(str).tolist(),
+        "orig": block["origin"].astype(str).tolist(),
+        "sent": block["sentence"].astype(str).tolist(),
+    }
+
+    current = s["words"][0]
+    hist = f"Okay! We'll do {n} words this round, hardest → easiest.\nSpell this word: {current}"
+    status = "Type your spelling attempt, or click definition/origin/sentence."
+    return s, hist, gr.update(value=current, interactive=False), status, f"Score: 0/{n}", gr.update(value="", interactive=True)
+
+def _check_state(state):
+    if not state or "words" not in state or state["i"] >= state["n"]:
+        return False
+    return True
 
-    # Expecting a column named 'word'. Fallback to first column if not present.
-    col = "word" if "word" in df.columns else df.columns[0]
-    s = df[col].astype(str)
+def check_attempt(state, attempt, history, current_word, score_md):
+    if not _check_state(state):
+        return state, history, current_word, "No round active. Click Start.", score_md, gr.update(value="")
+    attempt = (attempt or "").strip()
+    if not attempt:
+        return state, history, current_word, "Type your attempt first.", score_md, gr.update(value="")
 
-    prefix = (prefix or "").strip()
-    if not prefix:
-        return "Type a prefix to see matches."
+    target = state["words"][state["i"]]
+    if attempt.lower() == target.lower():
+        state["score"] += 1
+        msg = "✅ Correct!"
+    else:
+        msg = "❌ Not quite. Try again or ask for definition/origin/sentence."
 
-    matches = s[s.str.lower().str.startswith(prefix.lower())].head(20)
-    if matches.empty:
-        return "No matches."
-    return "\n".join(matches.tolist())
+    # append to history
+    history = f"{history}\nYou: {attempt}\nTutor: {msg}"
+    score_md = f"Score: {state['score']}/{state['n']}"
+
+    return state, history, current_word, msg, score_md, gr.update(value="")
+
+def _safe_text(val, fallback="Not available."):
+    v = (val or "").strip()
+    return v if v else fallback
+
+def show_def(state, history, current_word, score_md):
+    if not _check_state(state):
+        return state, history, current_word, "No round active. Click Start.", score_md
+    i = state["i"]
+    word = state["words"][i]
+    text = _safe_text(state["defs"][i])
+    history = f"{history}\nTutor (definition of {word}): {text}"
+    return state, history, current_word, f"Definition of {word}: {text}", score_md
+
+def show_origin(state, history, current_word, score_md):
+    if not _check_state(state):
+        return state, history, current_word, "No round active. Click Start.", score_md
+    i = state["i"]
+    word = state["words"][i]
+    text = _safe_text(state["orig"][i])
+    history = f"{history}\nTutor (origin of {word}): {text}"
+    return state, history, current_word, f"Origin of {word}: {text}", score_md
+
+def show_sentence(state, history, current_word, score_md):
+    if not _check_state(state):
+        return state, history, current_word, "No round active. Click Start.", score_md
+    i = state["i"]
+    word = state["words"][i]
+    text = _safe_text(state["sent"][i])
+    history = f"{history}\nTutor (sentence with {word}): {text}"
+    return state, history, current_word, f"Sentence: {text}", score_md
+
+def next_word(state, history, current_word, score_md):
+    if not _check_state(state):
+        return state, history, current_word, "No round active. Click Start.", score_md
+    state["i"] += 1
+    if state["i"] >= state["n"]:
+        # finished
+        summary = _summary(state)
+        history = f"{history}\n{summary}"
+        return {}, history, gr.update(value="", interactive=False), summary, f"Score: {state['score']}/{state['n']}"
+    # go to next word
+    w = state["words"][state["i"]]
+    history = f"{history}\nNext word: {w}"
+    status = "Type your spelling attempt, or click definition/origin/sentence."
+    return state, history, gr.update(value=w, interactive=False), status, f"Score: {state['score']}/{state['n']}"
+
+def stop_round(state, history, current_word, score_md):
+    if not state:
+        return {}, history, current_word, "Stopped.", score_md
+    summary = _summary(state)
+    history = f"{history}\n{summary}"
+    return {}, history, gr.update(value="", interactive=False), "Stopped.", f"Score: {state['score']}/{state['n']}"
 
 with gr.Blocks() as demo:
-    gr.Markdown("# NeMo Guardrails Demo (starter UI)\nType a prefix to see matching words from **words.csv**.")
-    inp = gr.Textbox(label="Prefix")
-    out = gr.Textbox(label="Matches", lines=12)
-    inp.change(fn=lookup, inputs=inp, outputs=out)
+    gr.Markdown("# NeMo Guardrails Demo (starter UI)\n**CLI-style spelling quiz** — works offline from `words.csv`.")
+
+    with gr.Row():
+        n_words = gr.Number(value=5, precision=0, label="Words this round")
+        start = gr.Button("Start quiz")
+
+    current_word = gr.Textbox(label="Spell this word", interactive=False)
+    attempt = gr.Textbox(label="Your attempt")
+    with gr.Row():
+        check = gr.Button("Check")
+        bdef = gr.Button("definition")
+        borg = gr.Button("origin")
+        bsent = gr.Button("sentence")
+        bnext = gr.Button("next")
+        bstop = gr.Button("stop")
+
+    status = gr.Markdown("")
+    score_md = gr.Markdown("Score: 0/0")
+    history = gr.Textbox(label="History", lines=14)
+
+    state = gr.State({})
+
+    # wire events
+    start.click(start_quiz, [n_words, state],
+                [state, history, current_word, status, score_md, attempt])
+
+    check.click(check_attempt, [state, attempt, history, current_word, score_md],
+                [state, history, current_word, status, score_md, attempt])
+
+    bdef.click(show_def, [state, history, current_word, score_md],
+               [state, history, current_word, status, score_md], queue=False)
+    borg.click(show_origin, [state, history, current_word, score_md],
+               [state, history, current_word, status, score_md], queue=False)
+    bsent.click(show_sentence, [state, history, current_word, score_md],
+                [state, history, current_word, status, score_md], queue=False)
+    bnext.click(next_word, [state, history, current_word, score_md],
+                [state, history, current_word, status, score_md], queue=False)
+    bstop.click(stop_round, [state, history, current_word, score_md],
+                [state, history, current_word, status, score_md], queue=False)
 
 if __name__ == "__main__":
     demo.launch()