Update app.py

app.py

@@ -7,7 +7,27 @@ from datetime import datetime, timedelta
 from transformers import AutoTokenizer, AutoModelForCausalLM
 
 # ----------------------------
-# Config and defaults
+# Default profile and blocks
+# ----------------------------
+DEFAULT_PROFILE = {
+    "name": "Learner",
+    "style": ["concise", "reflective", "Basque context where relevant"],
+    "goals": ["conversation-first learning", "daily language blocks", "CPU-only"]
+}
+
+DEFAULT_BLOCKS = [
+    {"type": "style", "rule": "Ask clarifying questions when uncertain."},
+    {"type": "vocab", "rule": "Use sensory detail + local place anchoring when writing creatively."},
+    {"type": "conversation", "rule": "Keep answers short and specific; avoid repeating conclusions."},
+    {"type": "conversation", "rule": "Offer warm, encouraging replies with a touch of humor or playfulness to lighten the mood."},
+    {"type": "conversation", "rule": "Use light satire, gentle irony, and clever humor when appropriate to keep dialogue playful and engaging."},
+    {"type": "conversation", "rule": "Clever swearing is allowed when it adds humor or emphasis, but keep it light, playful, and never offensive."}
+]
+
+BLOCKS_FILE = "blocks.json"
+
+# ----------------------------
+# Model options
 # ----------------------------
 MODEL_OPTIONS = {
     "Phi-3.5 Mini Instruct (4B)": "microsoft/Phi-3.5-mini-instruct",
@@ -16,74 +36,22 @@ MODEL_OPTIONS = {
     "Phi-3 Mini 128K Instruct (4B)": "microsoft/Phi-3-mini-128k-instruct"
 }
 
+# ----------------------------
+# Example prompts
+# ----------------------------
 EXAMPLES = [
-    # Comprehension
-    "Listen to this short passage and tell me the main idea in your own words.",
-    
-    # Explanation
-    "I’ll teach you something new: Solar panels turn sunlight into electricity. Can you explain that back to me simply?",
-    
-    # Vocabulary / Translation
-    "Here’s a new phrase: 'The sea is calm today.' Try saying it in Basque, then repeat it in English.",
-    
-    # Style play
+    "Read this short passage and tell me the main idea in your own words.",
+    "I’ll teach you a concept. Repeat it back to me in simple words: Solar panels turn sunlight into electricity.",
+    "Here’s a new phrase: 'The sea is calm today.' Try saying it in Basque.",
     "Let’s practice style: noir detective. Write one short sentence about Gros in that style.",
-    
-    # Literary reflection
     "Here’s a Shakespeare line: 'All the world’s a stage.' What do you think it means?",
-    
-    # Emotional reading
-    "Read this Dickens passage and tell me how it feels — happy, sad, or something else?",
-    
-    # Poetry + translation
+    "Read a Dickens passage and tell me how it feels — happy, sad, or something else?",
     "Translate this short poem line into another language, then tell me what mood it carries.",
-    
-    # Summarization + reflection
     "Summarize this text in two sentences, then say if it sounds optimistic or pessimistic.",
-    
-    # New: opinion practice
     "Read a short story and tell me what part you liked the most.",
-    
-    # New: correction loop
     "I’ll give you a sentence with a mistake: 'He go to school yesterday.' Can you fix it?"
 ]
 
-DEFAULT_PROFILE = {
-    "name": "Learner",
-    "style": ["concise", "reflective", "Basque context where relevant"],
-    "goals": ["conversation-first learning", "daily language blocks", "CPU-only"]
-}
-
-DEFAULT_BLOCKS = [
-    {
-        "type": "style",
-        "rule": "Ask clarifying questions when uncertain."
-    },
-    {
-        "type": "vocab",
-        "rule": "Use sensory detail + local place anchoring when writing creatively."
-    },
-    {
-        "type": "conversation",
-        "rule": "Keep answers short and specific; avoid repeating conclusions."
-    },
-    {
-        "type": "conversation",
-        "rule": "Offer warm, encouraging replies with a touch of humor or playfulness to lighten the mood."
-    },
-    {
-        "type": "conversation",
-        "rule": "Use light satire, gentle irony, and clever humor when appropriate to keep dialogue playful and engaging."
-    },
-    {
-        "type": "conversation",
-        "rule": "Clever swearing is allowed when it adds humor or emphasis, but keep it light, playful, and never offensive."
-    }
-]
-
-
-BLOCKS_FILE = "blocks.json"
-
 # ----------------------------
 # Persistence helpers
 # ----------------------------
@@ -100,18 +68,33 @@ def save_blocks(data):
     with open(BLOCKS_FILE, "w", encoding="utf-8") as f:
         json.dump(data, f, ensure_ascii=False, indent=2)
 
-def add_block(data, rule_text, block_type="conversation"):
-    if not rule_text.strip():
-        return data
-    entry = {
-        "type": block_type,
-        "rule": rule_text.strip(),
-        "validated": True,
-        "review_schedule": schedule_reviews()
-    }
-    data["language_blocks"].append(entry)
+def normalize_rule_text(text: str) -> str:
+    return " ".join(text.strip().split())
+
+def is_duplicate_rule(rules_list, new_rule_text, new_type="conversation"):
+    key = (new_type.lower(), normalize_rule_text(new_rule_text).lower())
+    for r in rules_list:
+        if (r.get("type", "").lower(), normalize_rule_text(r.get("rule", "")).lower()) == key:
+            return True
+    return False
+
+def add_block(data, rule_text, block_type="conversation", add_review=False):
+    rule_text = normalize_rule_text(rule_text)
+    if not rule_text:
+        return data, "Rule is empty. Nothing added."
+
+    rules = data.get("language_blocks", [])
+    if is_duplicate_rule(rules, rule_text, block_type):
+        return data, "Duplicate rule detected. Skipped."
+
+    entry = {"type": block_type, "rule": rule_text}
+    if add_review:
+        entry["review_schedule"] = schedule_reviews()
+
+    rules.append(entry)
+    data["language_blocks"] = rules
     save_blocks(data)
-    return data
+    return data, f"Added rule: {rule_text}"
 
 def schedule_reviews():
     today = datetime.utcnow().date()
@@ -124,7 +107,7 @@ def schedule_reviews():
 # ----------------------------
 # Model loading (CPU-only)
 # ----------------------------
-_loaded = {}  # cache
+_loaded = {}
 
 def load_model(model_id):
     if model_id in _loaded:
@@ -133,7 +116,7 @@ def load_model(model_id):
     model = AutoModelForCausalLM.from_pretrained(
         model_id,
         trust_remote_code=True,
-        torch_dtype=torch.float32  # CPU friendly
+        torch_dtype=torch.float32
     )
     model.eval()
     _loaded[model_id] = (tokenizer, model)
@@ -143,36 +126,25 @@ def load_model(model_id):
 # Prompt construction
 # ----------------------------
 def format_blocks(blocks):
-    return "\n".join([f"- [{b.get('type','rule')}] {b.get('rule','')}" for b in blocks])
+    return "\n".join([f"- [{b['type']}] {b['rule']}" for b in blocks])
 
 SYSTEM_TEMPLATE = """You are a conversation-first learning chatbot.
 Follow the user's style and goals, reinforce today's blocks, and confirm corrections.
-User style: {style}
-Goals: {goals}
 Active language blocks:
 {blocks}
-Guidelines:
-- Keep responses concise and specific.
-- Ask for clarification when needed.
-- Extract new patterns only when validated by the user.
 """
 
 def build_messages(user_text, profile, blocks):
-    system = SYSTEM_TEMPLATE.format(
-        style=", ".join(profile.get("style", [])),
-        goals=", ".join(profile.get("goals", [])),
-        blocks=format_blocks(blocks)
-    )
+    system = SYSTEM_TEMPLATE.format(blocks=format_blocks(blocks))
     return [
         {"role": "system", "content": system},
         {"role": "user", "content": user_text}
     ]
 
 # ----------------------------
-# Generate (with token/latency)
+# Generate
 # ----------------------------
 def chat(user_text, model_label, blocks_json):
-    # parse blocks from textarea (JSON or fallback lines)
     data = load_blocks()
     blocks = parse_blocks_editor(blocks_json, data.get("language_blocks", []))
 
@@ -194,29 +166,22 @@ def chat(user_text, model_label, blocks_json):
             **inputs,
             max_new_tokens=200,
             do_sample=False,
-            use_cache=False  # Avoid DynamicCache mismatch issues on some setups
+            use_cache=False
         )
     latency = time.time() - start
 
-    # slice out the generated continuation
     gen_text = tokenizer.decode(
         outputs[0][inputs["input_ids"].shape[-1]:],
         skip_special_tokens=True
     ).strip()
 
-    # token counts
     input_tokens = int(inputs["input_ids"].shape[-1])
     output_tokens = int(outputs[0].shape[-1] - inputs["input_ids"].shape[-1])
-
     metrics = f"Input tokens: {input_tokens} | Output tokens: {output_tokens} | Latency: {latency:.2f}s"
+
     return gen_text, metrics
 
 def parse_blocks_editor(text, fallback):
-    """
-    Accept either:
-    - JSON array of blocks
-    - Plain text lines ("type: rule")
-    """
     if not text or not text.strip():
         return fallback
     text = text.strip()
@@ -226,7 +191,6 @@ def parse_blocks_editor(text, fallback):
             return parsed
     except Exception:
         pass
-    # Fallback: each non-empty line becomes a block
     blocks = []
     for line in text.splitlines():
         line = line.strip()
@@ -240,37 +204,11 @@ def parse_blocks_editor(text, fallback):
     return blocks or fallback
 
 # ----------------------------
-# Reflection: extract new rule
+# Reflection
 # ----------------------------
-REFLECT_TEMPLATE = """From the user's last message and your reply, extract ONE reusable conversation rule.
-Return only the rule, no preface, max 20 words.
-Example rules:
-- Ask clarifying questions when uncertain.
-- Use sensory detail with local anchors in creative writing.
-- Summarize then assess tone (optimistic/pessimistic).
-User said:
-{user}
-Assistant replied:
-{assistant}
-Now output one new rule:"""
-
-def reflect_and_save(user_text, assistant_text, blocks_editor_value):
-    data = load_blocks()
-    # Propose a rule via a simple heuristic (no extra model call, keeps it lean)
-    # If you prefer model-based reflection, you can run a generation with REFLECT_TEMPLATE.
-    proposal = heuristic_rule(user_text, assistant_text)
-    data = add_block(data, proposal, block_type="conversation")
-
-    # Return updated blocks as pretty JSON to show in the editor
-    pretty = json.dumps(data["language_blocks"], ensure_ascii=False, indent=2)
-    return pretty, f"Saved rule: {proposal}"
-
 def heuristic_rule(user_text, assistant_text):
-    # Very simple heuristic: if assistant asked a question, reinforce clarification;
-    # otherwise, reinforce concise responses.
     if "?" in assistant_text:
         return "Ask clarifying questions when uncertain."
-    # If user asked for style or translation, capture that
     low = user_text.lower()
     if "translate" in low:
         return "Confirm translation intent and target tone before translating."
@@ -278,6 +216,13 @@ def heuristic_rule(user_text, assistant_text):
         return "Confirm style constraints before writing and keep it concise."
     return "Keep answers short, specific, and avoid repeating conclusions."
 
+def reflect_and_save(user_text, assistant_text, blocks_editor_value):
+    data = load_blocks()
+    proposal = heuristic_rule(user_text, assistant_text)
+    data, msg = add_block(data, proposal, block_type="conversation", add_review=False)
+    pretty = json.dumps(data["language_blocks"], ensure_ascii=False, indent=2)
+    return pretty, msg
+
 # ----------------------------
 # Gradio UI
 # ----------------------------
@@ -287,58 +232,4 @@ def launch():
 
     with gr.Blocks(title="Conversation Learning Lab (CPU)") as demo:
         gr.Markdown("# 🗣️ Conversation Learning Lab (CPU-friendly)")
-        gr.Markdown("Focus on daily dialogue. Reinforce validated language blocks. Transparent tokens and latency.")
-
-        with gr.Row():
-            model_dd = gr.Dropdown(
-                label="Choose a model",
-                choices=list(MODEL_OPTIONS.keys()),
-                value="Phi-3.5 Mini Instruct (4B)"
-            )
-
-        with gr.Row():
-            user_in = gr.Textbox(
-                label="Your message",
-                placeholder="Start a conversation or choose an example below...",
-                lines=3
-            )
-            
-        gr.Markdown("### 🧪 Try an example prompt:")
-        gr.Examples(
-            examples=EXAMPLES,
-            inputs=user_in
-        )
-
-        with gr.Row():
-            blocks_editor = gr.Textbox(
-                label="Today's blocks (JSON array or 'type: rule' lines)",
-                value=default_blocks_text,
-                lines=10
-            )
-
-        with gr.Row():
-            generate_btn = gr.Button("Generate (CPU)")
-            reflect_btn = gr.Button("Reflect & Save Rule")
-
-        with gr.Row():
-            output = gr.Textbox(label="Assistant", lines=8)
-        with gr.Row():
-            metrics = gr.Markdown("")
-
-        # Wire up events
-        generate_btn.click(
-            fn=chat,
-            inputs=[user_in, model_dd, blocks_editor],
-            outputs=[output, metrics]
-        )
-
-        reflect_btn.click(
-            fn=reflect_and_save,
-            inputs=[user_in, output, blocks_editor],
-            outputs=[blocks_editor, metrics]
-        )
-
-    demo.launch()
-
-if __name__ == "__main__":
-    launch()
+        gr.Markdown("Focus on daily dialogue. Reinforce validated language