Update app.py

app.py

@@ -1,57 +1,157 @@
 # app.py
 import os
+import json
+import requests
 import gradio as gr
-from groq import Groq
-
-# Load your Groq API key (set it in Hugging Face "Secrets")
-GROQ_API_KEY = os.getenv("GROQ_API_KEY")
-
-client = Groq(api_key=GROQ_API_KEY)
-
-# Define the translation prompt
-def translate_text(user_text, target_lang):
-    if not user_text.strip():
-        return "⚠️ Please enter some text."
-
-    # System prompt keeps the model focused
-    system_prompt = f"""
-    You are a multilingual translation assistant.
-    Supported languages: English, Spanish, French.
-
-    Task:
-    1. Detect the input language automatically.
-    2. Translate the input into the target language requested: {target_lang}.
-    3. Preserve meaning, tone, and formatting of the input.
-    4. Keep numbers, symbols, names, and special characters unchanged.
-    5. If the input is already in the target language, return it unchanged.
-    6. Respond with ONLY the translated text, no explanations or extra commentary.
-    """
-
-    # Call Groq API (Mistral or LLaMA etc.)
-    response = client.chat.completions.create(
-        model="mixtral-8x7b-32768",  # you can swap with mistral model available
-        messages=[
-            {"role": "system", "content": system_prompt},
-            {"role": "user", "content": user_text},
-        ],
-        temperature=0,  # translation should be deterministic
+from langdetect import detect, LangDetectException
+
+# Groq SDK (install in requirements.txt)
+try:
+    from groq import Groq
+except Exception:
+    Groq = None
+
+# Config (set these in your Space secrets)
+GROQ_API_KEY = os.getenv("GROQ_API_KEY")         # your Groq key
+GROQ_MODEL = os.getenv("GROQ_MODEL", "mixtral-8x7b-32768")
+HUGGINGFACE_TOKEN = os.getenv("HUGGINGFACE_TOKEN")  # hf_... token (optional but recommended)
+
+# Init clients (if keys provided)
+groq_client = None
+if GROQ_API_KEY and Groq is not None:
+    try:
+        groq_client = Groq(api_key=GROQ_API_KEY)
+    except Exception as e:
+        print("Groq client init failed:", repr(e))
+
+# Simple mapping for UI -> code
+LANG_UI_TO_CODE = {"English": "en", "Spanish": "es", "French": "fr"}
+
+SYSTEM_PROMPT = """
+You are a multilingual translation assistant.
+Supported languages: English, Spanish, French.
+
+Task:
+1. Detect the input language automatically.
+2. Translate the input into the exact target language requested by the user.
+3. Preserve meaning, tone, and formatting.
+4. Keep numbers, symbols, names and special characters unchanged.
+5. If the input is already in the target language, return it unchanged.
+6. Output ONLY the translated text, no commentary.
+"""
+
+def call_groq(user_text, target_lang_ui):
+    if not groq_client:
+        raise RuntimeError("Groq client not configured")
+    # Put the target explicitly for determinism
+    messages = [
+        {"role": "system", "content": SYSTEM_PROMPT},
+        {"role": "user", "content": f"Target language: {target_lang_ui}\n\n{user_text}"},
+    ]
+    # Best-effort: extract content from different response shapes
+    chat = groq_client.chat.completions.create(
+        model=GROQ_MODEL,
+        messages=messages,
+        temperature=0,
+        max_tokens=2048,
     )
+    # SDK usually returns .choices[0].message.content
+    try:
+        return chat.choices[0].message.content.strip()
+    except Exception:
+        # fallback for dict-like response
+        try:
+            return chat["choices"][0]["message"]["content"].strip()
+        except Exception as e:
+            print("Unexpected Groq response shape:", repr(e))
+            raise
+
+def call_hf_opus(user_text, src_code, tgt_code):
+    # map most common pairs to explicit model ids
+    model_map = {
+        ("en","es"): "Helsinki-NLP/opus-mt-en-es",
+        ("es","en"): "Helsinki-NLP/opus-mt-es-en",
+        ("en","fr"): "Helsinki-NLP/opus-mt-en-fr",
+        ("fr","en"): "Helsinki-NLP/opus-mt-fr-en",
+        ("es","fr"): "Helsinki-NLP/opus-mt-es-fr",
+        ("fr","es"): "Helsinki-NLP/opus-mt-fr-es",
+    }
+    model_id = model_map.get((src_code, tgt_code)) or f"Helsinki-NLP/opus-mt-{src_code}-{tgt_code}"
 
-    return response.choices[0].message.content.strip()
+    url = f"https://api-inference.huggingface.co/models/{model_id}"
+    headers = {"Authorization": f"Bearer {HUGGINGFACE_TOKEN}"} if HUGGINGFACE_TOKEN else {}
+    payload = {"inputs": user_text}
 
-# Gradio UI
+    resp = requests.post(url, headers=headers, json=payload, timeout=30)
+    if resp.status_code != 200:
+        raise RuntimeError(f"Hugging Face fallback failed: {resp.status_code} {resp.text}")
+
+    data = resp.json()
+    # handle common response shapes:
+    if isinstance(data, list) and len(data) > 0:
+        first = data[0]
+        if isinstance(first, dict):
+            # prefer common keys
+            for k in ("translation_text", "generated_text", "text"):
+                if k in first:
+                    return first[k]
+            # otherwise return first value
+            return next(iter(first.values()))
+        else:
+            return str(first)
+    if isinstance(data, dict):
+        for k in ("translation_text", "generated_text", "text"):
+            if k in data:
+                return data[k]
+        return json.dumps(data)
+    return str(data)
+
+def detect_lang_code(text):
+    try:
+        code = detect(text)
+        # keep only en/es/fr; if another, default to 'en' for fallback routing
+        return code if code in ("en","es","fr") else "en"
+    except LangDetectException:
+        return "en"
+
+def translate_text(user_text, target_lang_ui):
+    user_text = (user_text or "").strip()
+    if not user_text:
+        return "⚠️ Please enter some text to translate."
+    target_code = LANG_UI_TO_CODE.get(target_lang_ui, "en")
+
+    # First: try Groq (preferred)
+    try:
+        if groq_client:
+            out = call_groq(user_text, target_lang_ui)
+            if out:
+                return out
+    except Exception as e:
+        print("Groq call failed:", repr(e))
+
+    # Fallback: detect source and call HF OPUS-MT models
+    try:
+        src_code = detect_lang_code(user_text)
+        if src_code == target_code:
+            # already same language
+            return user_text
+        out = call_hf_opus(user_text, src_code, target_code)
+        return out.strip()
+    except Exception as e:
+        print("Hugging Face fallback failed:", repr(e))
+        return f"Error: translation failed. Check Space logs for details."
+
+# ----------------- Gradio UI -----------------
 with gr.Blocks() as demo:
     gr.Markdown("## 🌐 Hackathon Translator (EN/ES/FR)")
 
     with gr.Row():
-        user_text = gr.Textbox(label="Enter your text", lines=4, placeholder="Type something...")
-        target_lang = gr.Dropdown(["English", "Spanish", "French"], value="English", label="Target Language")
-
-    output_text = gr.Textbox(label="Translated Output", lines=4)
-
-    translate_btn = gr.Button("Translate")
+        txt = gr.Textbox(label="Enter your text", lines=6, placeholder="Type or paste text here...")
+        tgt = gr.Dropdown(choices=["English","Spanish","French"], value="English", label="Target Language")
 
-    translate_btn.click(fn=translate_text, inputs=[user_text, target_lang], outputs=output_text)
+    out = gr.Textbox(label="Translated Output", lines=6)
+    btn = gr.Button("Translate")
+    btn.click(fn=translate_text, inputs=[txt, tgt], outputs=[out])
 
 if __name__ == "__main__":
     demo.launch()