Update app.py

app.py

@@ -7,23 +7,66 @@ from typing import List, Tuple, Any
 API_URL = "https://api.deepseek.com/v1/chat/completions"
 API_KEY = os.getenv("DEEPSEEK_API_KEY")
 
+# Debug API key loading
+print(f"🔑 API Key Status: {'✅ Loaded' if API_KEY else '❌ Missing'}")
+if API_KEY:
+    print(f"🔑 API Key Preview: {API_KEY[:10]}...")
+
+# Validate API key at startup
+if not API_KEY:
+    print("❌ ERROR: DEEPSEEK_API_KEY environment variable not found!")
+    print("💡 Please set your API key:")
+    print("   - Local: export DEEPSEEK_API_KEY='your-key'")
+    print("   - HF Spaces: Add to Repository Secrets")
+
 headers = {
     "Authorization": f"Bearer {API_KEY}",
     "Content-Type": "application/json"
 }
 
+def test_api_connection():
+    """Test if API is accessible"""
+    if not API_KEY:
+        return False, "API key not found"
+    
+    try:
+        response = requests.post(
+            API_URL,
+            headers=headers,
+            json={
+                "model": "deepseek-chat",
+                "messages": [{"role": "user", "content": "test"}],
+                "max_tokens": 10
+            },
+            timeout=10
+        )
+        return response.status_code == 200, f"Status: {response.status_code}"
+    except Exception as e:
+        return False, str(e)
+
 def query_deepseek(message: str, history: List[Tuple[str, str]]) -> str:
     """Query DeepSeek API with robust error handling"""
+    
+    # Check API key first
+    if not API_KEY:
+        return "❌ **API Key Missing**\n\nPlease set DEEPSEEK_API_KEY environment variable:\n- Local: `export DEEPSEEK_API_KEY='your-key'`\n- HF Spaces: Add to Repository Secrets"
+    
     try:
         # Build conversation history
         messages = [{"role": "system", "content": "You are a helpful assistant."}]
+        
+        # Add chat history
         for user_msg, bot_msg in history:
-            messages.extend([
-                {"role": "user", "content": user_msg},
-                {"role": "assistant", "content": bot_msg}
-            ])
+            if user_msg and bot_msg:  # Skip empty messages
+                messages.extend([
+                    {"role": "user", "content": user_msg},
+                    {"role": "assistant", "content": bot_msg}
+                ])
+        
+        # Add current message
         messages.append({"role": "user", "content": message})
 
+        # API request
         response = requests.post(
             API_URL,
             headers=headers,
@@ -31,62 +74,122 @@ def query_deepseek(message: str, history: List[Tuple[str, str]]) -> str:
                 "model": "deepseek-chat",
                 "messages": messages,
                 "temperature": 0.7,
-                "max_tokens": 1024
+                "max_tokens": 1024,
+                "stream": False
             },
             timeout=30
         )
+        
+        # Detailed error handling
+        if response.status_code == 401:
+            return "❌ **Authentication Error**\nInvalid API key. Please check your DEEPSEEK_API_KEY."
+        elif response.status_code == 403:
+            return "❌ **Access Denied**\nAPI key doesn't have permission or quota exceeded."
+        elif response.status_code == 404:
+            return "❌ **API Not Found**\nCheck if the API URL is correct: https://api.deepseek.com/v1/chat/completions"
+        elif response.status_code == 429:
+            return "❌ **Rate Limited**\nToo many requests. Please wait and try again."
+        elif response.status_code >= 500:
+            return f"❌ **Server Error**\nDeepSeek server error (HTTP {response.status_code}). Try again later."
+        
         response.raise_for_status()
-        return response.json()["choices"][0]["message"]["content"]
+        
+        # Parse response
+        result = response.json()
+        if "choices" in result and len(result["choices"]) > 0:
+            return result["choices"][0]["message"]["content"]
+        else:
+            return f"❌ **Unexpected Response**\n```json\n{result}\n```"
     
+    except requests.exceptions.Timeout:
+        return "❌ **Timeout Error**\nRequest took too long. Please try again."
+    except requests.exceptions.ConnectionError:
+        return "❌ **Connection Error**\nCannot connect to DeepSeek API. Check your internet connection."
+    except requests.exceptions.RequestException as e:
+        return f"❌ **Request Error**\n{str(e)}"
     except Exception as e:
-        return f"⚠️ Error: {str(e)}"
+        return f"❌ **Unexpected Error**\n{str(e)}"
 
-# Gradio interface with explicit component definitions
 def create_interface():
-    with gr.Blocks(analytics_enabled=False) as demo:  # Disable analytics to prevent schema issues
-        gr.Markdown("## 🤖 DeepSeek API Chat")
+    # Test API connection at startup
+    api_ok, api_msg = test_api_connection()
+    status_msg = f"🟢 API Connected: {api_msg}" if api_ok else f"🔴 API Issue: {api_msg}"
+    
+    with gr.Blocks(
+        title="DeepSeek Chat",
+        theme=gr.themes.Soft(),
+        analytics_enabled=False
+    ) as demo:
+        
+        gr.Markdown("# 🤖 DeepSeek API Chat")
+        gr.Markdown(f"**Status:** {status_msg}")
         
         chatbot = gr.Chatbot(
             label="Conversation",
-            bubble_full_width=False
-        )
-        msg = gr.Textbox(
-            label="Your Message",
-            placeholder="Type here...",
-            scale=7
+            bubble_full_width=False,
+            height=500
         )
         
         with gr.Row():
-            submit = gr.Button("Send", variant="primary")
-            clear = gr.Button("Clear")
+            msg = gr.Textbox(
+                label="Your Message",
+                placeholder="Type your message here...",
+                scale=4,
+                lines=2
+            )
+            with gr.Column(scale=1):
+                submit = gr.Button("Send 📤", variant="primary")
+                clear = gr.Button("Clear 🗑️")
 
-        # Fixed chat handler with type-safe implementation
-        def respond(message: str, chat_history: List[Tuple[str, str]]) -> Tuple[str, List[Tuple[str, str]]]:
-            bot_message = query_deepseek(message, chat_history)
-            chat_history.append((message, bot_message))
+        # Chat handler
+        def respond(message: str, chat_history: List[List[str]]) -> Tuple[str, List[List[str]]]:
+            if not message.strip():
+                return "", chat_history
+            
+            # Convert to tuple format for API
+            history_tuples = [(h[0], h[1]) for h in chat_history if len(h) >= 2]
+            bot_message = query_deepseek(message.strip(), history_tuples)
+            chat_history.append([message, bot_message])
             return "", chat_history
 
+        # Event handlers
         msg.submit(respond, [msg, chatbot], [msg, chatbot])
         submit.click(respond, [msg, chatbot], [msg, chatbot])
-        clear.click(lambda: None, None, chatbot, queue=False)
+        clear.click(lambda: [], None, chatbot, queue=False)
         
+        # Examples
         gr.Examples(
             examples=[
-                ["Explain quantum computing simply"],
-                ["Write a Python function for Fibonacci"],
-                ["What makes DeepSeek special?"]
+                ["Hello! Can you introduce yourself?"],
+                ["Explain quantum computing in simple terms"],
+                ["Write a Python function to calculate Fibonacci numbers"],
+                ["What are the key features of DeepSeek?"],
+                ["Help me debug this error: 'list index out of range'"]
             ],
             inputs=msg
         )
+        
+        # Footer
+        gr.Markdown("""
+        ---
+        **Troubleshooting:**
+        - ❌ API Key Missing → Set `DEEPSEEK_API_KEY` environment variable
+        - ❌ 401 Error → Invalid API key
+        - ❌ 403 Error → No permission or quota exceeded
+        - ❌ 404 Error → Wrong API URL
+        """)
     
     return demo
 
-# Launch with explicit configuration
+# Launch configuration
 if __name__ == "__main__":
+    print("🚀 Starting DeepSeek Gradio App...")
+    
     app = create_interface()
     app.launch(
         server_name="0.0.0.0",
         server_port=7860,
-        show_error=True
-     #   enable_queue=True  # Prevents timeout issues
+        show_error=True,
+        share=False,  # Set to True if you want public link
+        quiet=False
     )