Fix: Replace AI model with reliable dictionary-based translation (always works!)

app.py

@@ -2,6 +2,7 @@ import gradio as gr
 from huggingface_hub import InferenceClient
 from algospeak_dictionary import get_algospeak_context, ALGOSPEAK_DICT
 import os
+import re
 
 # Initialize inference client with HF token (automatically provided in Spaces)
 hf_token = os.getenv("HF_TOKEN") or os.getenv("HUGGINGFACE_TOKEN")
@@ -14,67 +15,107 @@ ALGOSPEAK_EXAMPLES = get_algospeak_context()
 # Google Flan-T5-XXL is excellent for instruction-following and translation tasks
 MODEL = "google/flan-t5-xxl"
 
+def translate_to_algospeak_simple(text):
+    """Rule-based translation using the dictionary (always works!)"""
+    result = text
+    
+    # Create reverse mapping: meaning -> algospeak term
+    replacements = {
+        # Death and violence
+        "suicide": "sewerslide",
+        "kill": "unalive",
+        "killing": "unaliving",
+        "killed": "unalived",
+        "die": "unalive",
+        "died": "unalived",
+        "death": "unalive",
+        "dead": "unalived",
+        
+        # Weapons and war
+        "gun": "pew pew",
+        "guns": "pew pews",
+        "shooting": "pew pew",
+        "shot": "pew pew",
+        "weapon": "noodle",
+        "weapons": "noodles",
+        "war": "cornucopia",
+        "bomb": "kaboom",
+        
+        # Adult content
+        "sex": "seggs",
+        "sexual": "seggs",
+        "porn": "corn",
+        "pornography": "corn",
+        "lesbian": "le$bian",
+        "gay": "g@y",
+        
+        # Health
+        "COVID": "mascara",
+        "COVID-19": "mascara",
+        "coronavirus": "mascara",
+        "vaccine": "backshot",
+        "pandemic": "panini",
+        
+        # LGBTQ+
+        "LGBTQ": "leg booty",
+        "LGBTQ+": "leg booty",
+        
+        # Sexual violence
+        "rape": "grape",
+        "sexual assault": "SA",
+        
+        # Other
+        "sex worker": "accountant",
+        "stripper": "skripper",
+        "marijuana": "lettuce",
+        "weed": "lettuce",
+    }
+    
+    # Sort by length (longest first) to avoid partial replacements
+    for original, coded in sorted(replacements.items(), key=lambda x: len(x[0]), reverse=True):
+        # Case-insensitive replacement
+        pattern = re.compile(re.escape(original), re.IGNORECASE)
+        result = pattern.sub(coded, result)
+    
+    if result == text:
+        return f"✨ No sensitive terms detected!\n\nOriginal: {text}\n\n💡 Tip: Try terms like 'suicide', 'sex', 'war', 'COVID', etc."
+    
+    return f"🔄 Translated to AlgoSpeak:\n\n{result}"
+
 def translate_to_algospeak(text):
     """Translates normal text to AlgoSpeak"""
-    # Simplified prompt for FLAN-T5 (works better with concise instructions)
-    prompt = f"""Convert this text to AlgoSpeak (coded language to avoid content moderation):
-
-Reference terms:
-- death/kill → unalive
-- sex → seggs
-- gun → pew pew
-- war → cornucopia
-- COVID → mascara
-- LGBTQ+ → leg booty
-- sex worker → accountant
-- rape → grape
-- suicide → sewerslide
-
-Text: {text}
-
-AlgoSpeak version:"""
+    if not text or not text.strip():
+        return "⚠️ Please enter some text to translate."
+    
+    # Use simple dictionary-based translation (always works!)
+    return translate_to_algospeak_simple(text)
 
-    try:
-        response = client.text_generation(
-            prompt,
-            model=MODEL,
-            max_new_tokens=200,
-            temperature=0.7
-        )
-        return response.strip()
-    except Exception as e:
-        return f"⚠️ Error: {str(e)}\n\nPlease try again or use the Dictionary Search tab."
+def interpret_algospeak_simple(text):
+    """Rule-based interpretation using the dictionary (always works!)"""
+    result = text
+    found_terms = []
+    
+    # Direct mapping from algospeak -> meaning
+    for term, meaning in ALGOSPEAK_DICT.items():
+        # Case-insensitive search
+        pattern = re.compile(re.escape(term), re.IGNORECASE)
+        if pattern.search(result):
+            found_terms.append(f"'{term}' → {meaning}")
+            result = pattern.sub(f"[{meaning}]", result)
+    
+    if not found_terms:
+        return f"✨ No AlgoSpeak terms detected!\n\nOriginal: {text}\n\n💡 Tip: Try terms like 'unalive', 'seggs', 'pew pew', 'mascara', etc."
+    
+    explanation = "\n".join(found_terms)
+    return f"🔍 Interpreted:\n\n{result}\n\n📖 Terms found:\n{explanation}"
 
 def interpret_algospeak(text):
     """Interprets AlgoSpeak to plain language"""
-    # Simplified prompt for FLAN-T5
-    prompt = f"""Translate this AlgoSpeak (coded language) to plain English:
-
-Reference:
-- unalive → death/kill/suicide
-- seggs → sex
-- pew pew → gun/shooting
-- cornucopia → war
-- mascara → COVID-19
-- leg booty → LGBTQ+
-- accountant → sex worker
-- grape → rape
-- sewerslide → suicide
-
-AlgoSpeak: {text}
-
-Plain English:"""
-
-    try:
-        response = client.text_generation(
-            prompt,
-            model=MODEL,
-            max_new_tokens=200,
-            temperature=0.3
-        )
-        return response.strip()
-    except Exception as e:
-        return f"⚠️ Error: {str(e)}\n\nPlease try again or use the Dictionary Search tab."
+    if not text or not text.strip():
+        return "⚠️ Please enter some AlgoSpeak text to interpret."
+    
+    # Use simple dictionary-based interpretation (always works!)
+    return interpret_algospeak_simple(text)
 
 def search_dictionary(query):
     """Search terms in the AlgoSpeak dictionary"""
@@ -92,17 +133,17 @@ def search_dictionary(query):
 
 # Interface Gradio
 with gr.Blocks(theme=gr.themes.Soft(), title="AlgoSpeak AI") as demo:
-    gr.Markdown(f"""
-    # 🗣️ AlgoSpeak AI
+    gr.Markdown("""
+    # 🗣️ AlgoSpeak Translator
     
     **AlgoSpeak** is a language used to circumvent content moderation algorithms on social media platforms.
     
-    This AI can:
-    - 📝 Translate plain text → AlgoSpeak
+    This tool can:
+    - 📝 Translate plain text → AlgoSpeak (dictionary-based)
     - 🔍 Interpret AlgoSpeak → plain language
     - 📖 Search through 60+ catalogued terms
     
-    🤖 **Current Model:** `{MODEL}`
+    💡 **How it works:** Uses pattern matching with a curated dictionary of AlgoSpeak terms.
     """)
     
     with gr.Tab("🌐 Translate to AlgoSpeak"):