Update app.py

app.py

@@ -1,95 +1,171 @@
-import gradio as gr
-import requests
-import os
+# yellowflash_multi_backend.py
+# Minimal Gradio chat interface with Gemini (Google) and Groq (OpenAI-compatible)
+# WARNING: This file contains placeholders for API keys. Replace with your keys locally ONLY.
 
-# --- 1. SET YOUR API KEYS ---
-# It's safest to set these as environment variables or Hugging Face secrets.
-GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY", "AIzaSyAPfDiu2V_aD6un00qHt5bkISm6C0Pkx7o") 
-GROQ_API_KEY = os.getenv("GROQ_API_KEY", "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")
+import os
+import time
+import random
+import requests
+import gradio as gr
 
+# -------------------------
+# 1) HARDCODED KEYS (replace with your real keys)
+# -------------------------
+# Replace the placeholders below with your actual keys if you insist on hardcoding.
+# DO NOT commit or share the file with real keys.
+GOOGLE_API_KEY = "AIzaSyAPfDiu2V_aD6un00qHt5bkISm6C0Pkx7o"   # e.g. from makersuite/google Cloud
+GROQ_API_KEY   = "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"     # starts with gsk_... from Groq Console
 
-# --- 2. CONFIGURE YOUR MODELS ---
+# -------------------------
+# 2) MODELS config (Gemini + Groq)
+# -------------------------
 MODELS = {
-    "Gemini 2.O Flash": {
+    "Gemini 1.5 Pro": {
+        # Gemini content generation endpoint (example from earlier)
         "api_url": "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent",
         "api_key": GOOGLE_API_KEY,
         "handler": "gemini"
     },
-    "meta llama 4 + ChatGPT4o mini": {
+    "Groq LLaMA-4": {
+        # Groq's OpenAI-compatible chat completions URL (from console screenshot)
         "api_url": "https://api.groq.com/openai/v1/chat/completions",
-        "api_key": ,GROQ_API_KEY,
-        "model_name": "meta llama 4",
-        "handler": "groq"
+        "api_key": GROQ_API_KEY,
+        # Example model name shown in Groq UI—change if different
+        "model_name": "meta-llama/llama-4-scout-17b-16e-instruct",
+        "handler": "openai_compat"
     }
 }
 
-# --- 3. THE MAIN CHAT FUNCTION ---
+# -------------------------
+# 3) Retry helper with exponential backoff + jitter
+# -------------------------
+def post_with_retries(url, headers, json_payload, timeout=30,
+                      max_retries=5, base_delay=1.0, max_delay=20.0):
+    attempt = 0
+    last_exc = None
+    while attempt <= max_retries:
+        try:
+            resp = requests.post(url, headers=headers, json=json_payload, timeout=timeout)
+            resp.raise_for_status()
+            return resp
+        except requests.exceptions.HTTPError as e:
+            last_exc = e
+            status = getattr(e.response, "status_code", None)
+            # Retry for rate-limit / server errors
+            if status in (429, 502, 503, 504):
+                attempt += 1
+                delay = min(max_delay, base_delay * (2 ** (attempt - 1)))
+                jitter = random.random()
+                sleep_time = delay + jitter
+                print(f"[retry] HTTP {status}, attempt {attempt}/{max_retries}, sleeping {sleep_time:.2f}s")
+                time.sleep(sleep_time)
+                continue
+            else:
+                # non-retryable HTTP error
+                raise
+        except requests.exceptions.RequestException as e:
+            last_exc = e
+            attempt += 1
+            delay = min(max_delay, base_delay * (2 ** (attempt - 1)))
+            jitter = random.random()
+            sleep_time = delay + jitter
+            print(f"[retry] Network err attempt {attempt}/{max_retries}, sleeping {sleep_time:.2f}s")
+            time.sleep(sleep_time)
+            continue
+    # exhausted retries
+    raise last_exc
+
+# -------------------------
+# 4) Chat logic for handlers
+# -------------------------
+def call_gemini(api_url, api_key, history, message):
+    headers = {"Content-Type": "application/json", "x-goog-api-key": api_key}
+    api_history = []
+    # Gemini expects 'contents' with parts per role as in earlier example
+    for user_msg, model_msg in history:
+        api_history.append({"role": "user",  "parts": [{"text": user_msg}]})
+        api_history.append({"role": "model", "parts": [{"text": model_msg}]})
+    api_history.append({"role": "user", "parts": [{"text": message}]})
+    json_payload = {"contents": api_history}
+
+    resp = post_with_retries(api_url, headers, json_payload, timeout=30)
+    data = resp.json()
+    # defensive parsing
+    try:
+        ans = data.get("candidates", [{}])[0].get("content", {}).get("parts", [{}])[0].get("text", "")
+    except Exception:
+        ans = str(data)
+    return ans or "Gemini: no reply."
+
+def call_openai_compat(api_url, api_key, model_name, history, message):
+    headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
+    api_history = []
+    for user_msg, model_msg in history:
+        api_history.append({"role": "user", "content": user_msg})
+        api_history.append({"role": "assistant", "content": model_msg})
+    api_history.append({"role": "user", "content": message})
+
+    json_payload = {"messages": api_history, "model": model_name}
+    resp = post_with_retries(api_url, headers, json_payload, timeout=30)
+    data = resp.json()
+    # parse OpenAI-compatible response
+    if "choices" in data and data["choices"]:
+        choice = data["choices"][0]
+        if "message" in choice:
+            return choice["message"].get("content", "")
+        elif "text" in choice:
+            return choice["text"]
+    return str(data)
+
+# -------------------------
+# 5) Unified chat function used by Gradio
+# -------------------------
 def chat_fn(message, history, selected_model):
-    config = MODELS[selected_model]
-    handler_type = config["handler"]
-    api_url = config["api_url"]
-    api_key = config["api_key"]
+    cfg = MODELS.get(selected_model)
+    if not cfg:
+        return f"Unknown model: {selected_model}"
+
+    handler = cfg["handler"]
+    api_url = cfg["api_url"]
+    api_key = cfg["api_key"]
 
-    if "YOUR_API_KEY" in api_key:
-        return f"Error: API key for {selected_model} is not set. Please replace the placeholder in the code."
+    if not api_key or "YOUR_" in api_key:
+        return (f"Error: API key for {selected_model} not set. "
+                "Replace placeholder with key string in the script or use environment vars.")
 
     try:
-        # --- Gemini API Logic ---
-        if handler_type == "gemini":
-            headers = {"Content-Type": "application/json", "x-goog-api-key": api_key}
-            
-            # FIXED: Changed the broken list comprehension to a standard for loop
-            api_history = []
-            for user_msg, model_msg in history:
-                api_history.append({"role": "user", "parts": [{"text": user_msg}]})
-                api_history.append({"role": "model", "parts": [{"text": model_msg}]})
-            api_history.append({"role": "user", "parts": [{"text": message}]})
-            
-            json_payload = {"contents": api_history}
-            
-            resp = requests.post(api_url, headers=headers, json=json_payload, timeout=30)
-            resp.raise_for_status()
-            ans = resp.json()["candidates"][0]["content"]["parts"][0]["text"]
-
-        # --- OpenAI API Logic ---
-        elif handler_type == "openai":
-            headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
-
-            # FIXED: Changed the broken list comprehension to a standard for loop
-            api_history = []
-            for user_msg, model_msg in history:
-                api_history.append({"role": "user", "content": user_msg})
-                api_history.append({"role": "assistant", "content": model_msg})
-            api_history.append({"role": "user", "content": message})
-
-            json_payload = {"messages": api_history, "model": config["model_name"]}
-            
-            resp = requests.post(api_url, headers=headers, json=json_payload, timeout=30)
-            resp.raise_for_status()
-            ans = resp.json()["choices"][0]["message"]["content"]
+        if handler == "gemini":
+            return call_gemini(api_url, api_key, history, message)
+
+        elif handler == "openai_compat":
+            model_name = cfg.get("model_name")
+            return call_openai_compat(api_url, api_key, model_name, history, message)
+
+        else:
+            return f"Unsupported handler: {handler}"
 
-    except requests.exceptions.RequestException as e:
-        ans = f"Network Error: {e}"
     except Exception as e:
-        ans = f"Error: {e}\nResponse: {resp.text if 'resp' in locals() else 'No response'}"
-        
-    return ans
+        # avoid printing full responses that might contain secrets
+        try:
+            err_text = str(e)
+        except Exception:
+            err_text = "Unknown error"
+        return f"Error: {err_text}"
 
-# --- 4. BUILD THE GRADIO UI ---
+# -------------------------
+# 6) Gradio UI (chat)
+# -------------------------
 with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# ⚡Yellowflash.ai")
-    gr.Markdown("Select a model and start your conversation.")
-    
+    gr.Markdown("# ⚡ Yellowflash,ai")
+    gr.Markdown("Select a model and start chatting. Keys are hardcoded in the script (not secure).")
+
     with gr.Row():
-        model_selector = gr.Radio(
-            choices=list(MODELS.keys()),
-            value=list(MODELS.keys())[0],
-            label="Choose your model"
-        )
-
-    gr.ChatInterface(
-        chat_fn,
-        additional_inputs=[model_selector],
-    )
-
-demo.launch(share=True)
+        model_selector = gr.Radio(choices=list(MODELS.keys()),
+                                  value=list(MODELS.keys())[0],
+                                  label="Choose your model")
+
+    gr.ChatInterface(chat_fn, additional_inputs=[model_selector])
+
+# throttle concurrency to reduce rate-limit issues
+demo.queue(concurrency_count=1, max_size=20)
+demo.launch(share=True)