Update app.py

app.py

@@ -1,11 +1,14 @@
-import gradio as gr
-import requests
-import json
-from typing import List, Dict, Generator
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from typing import List, Dict, Optional
 import asyncio
 import aiohttp
+import json
 import time
 import logging
+from fastapi.responses import StreamingResponse
+import uvicorn
 
 # Configure logging
 logging.basicConfig(level=logging.INFO)
@@ -15,261 +18,230 @@ logger = logging.getLogger(__name__)
 POLLINATIONS_API_URL = "https://text.pollinations.ai/openai"
 API_KEY = "wPGHlU-7pPYlOetQ"
 MAX_CONTEXT_MESSAGES = 15
-DEFAULT_MODEL = "openai"
 
-class AIAssistant:
-    def __init__(self):
-        self.conversation_history = []
-    
-    async def generate_streaming_response(self, prompt: str, history: List[List[str]]) -> Generator[str, None, None]:
-        """Generate streaming response from Pollinations API"""
-        
-        # Convert Gradio history to conversation format
-        messages = [{
-            'role': 'system',
-            'content': 'आप एक helpful AI assistant हैं। User को Hindi और English दोनों languages में helpful और accurate answers देते हैं। आप friendly, conversational और natural tone में बात करते हैं। Code माँगने पर proper formatting के साथ दें। हमेशा relevant और उपयोगी जवाब दें।'
-        }]
-        
-        # Add conversation history
-        for user_msg, assistant_msg in history[-MAX_CONTEXT_MESSAGES:]:
-            if user_msg:
-                messages.append({"role": "user", "content": user_msg})
-            if assistant_msg:
-                messages.append({"role": "assistant", "content": assistant_msg})
-        
-        # Add current prompt
-        messages.append({"role": "user", "content": prompt})
-        
-        payload = {
-            'model': DEFAULT_MODEL,
-            'messages': messages,
-            'temperature': 0.7,
-            'max_tokens': 2000,
-            'top_p': 0.9,
-            'stream': True,
-            'private': True,
-            'referrer': API_KEY,
-            'seed': int(time.time()) % 1000000
-        }
-        
-        try:
-            async with aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=120)) as session:
-                async with session.post(
-                    POLLINATIONS_API_URL,
-                    json=payload,
-                    headers={
-                        'Content-Type': 'application/json',
-                        'Accept': 'text/event-stream',
-                        'User-Agent': 'AI-Assistant-HF/1.0'
-                    }
-                ) as response:
-                    
-                    if response.status != 200:
-                        error_text = await response.text()
-                        yield f"❌ API Error: {response.status} - {error_text}"
-                        return
-                    
-                    full_response = ""
-                    buffer = ""
-                    
-                    async for chunk in response.content.iter_chunked(1024):
-                        buffer += chunk.decode('utf-8', errors='ignore')
-                        lines = buffer.split('\n')
-                        buffer = lines[-1]  # Keep incomplete line in buffer
-                        
-                        for line in lines[:-1]:
-                            line = line.strip()
-                            if line.startswith('data: '):
-                                data = line[6:]
-                                
-                                if data == '[DONE]':
-                                    return
-                                    
-                                try:
-                                    parsed = json.loads(data)
-                                    content = parsed.get('choices', [{}])[0].get('delta', {}).get('content', '')
-                                    if content:
-                                        full_response += content
-                                        yield full_response
-                                except json.JSONDecodeError:
-                                    continue
-                                    
-        except asyncio.TimeoutError:
-            yield "⏰ Request timeout - कृपया दोबारा कोशिश करें"
-        except Exception as e:
-            logger.error(f"API Error: {str(e)}")
-            yield f"❌ Connection Error: {str(e)}"
+# FastAPI app
+app = FastAPI(
+    title="AI Assistant API",
+    description="Server API for AI Assistant powered by Pollinations",
+    version="1.0.0"
+)
 
-    def chat_response(self, message: str, history: List[List[str]]):
-        """Main chat response function for Gradio"""
-        if not message or not message.strip():
-            return history, ""
-        
-        # Run async function in sync context
-        try:
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
-            
-            # Get final response
-            full_response = ""
-            async def get_response():
-                nonlocal full_response
-                async for response in self.generate_streaming_response(message, history):
-                    full_response = response
-            
-            loop.run_until_complete(get_response())
-            loop.close()
-            
-            if not full_response:
-                full_response = "माफ करें, मैं आपका सवाल समझ नहीं पाया। कृपया दोबारा कोशिश करें।"
-            
-            # Add to history
-            history.append([message, full_response])
-            return history, ""
-            
-        except Exception as e:
-            logger.error(f"Chat error: {str(e)}")
-            error_message = f"❌ तकनीकी समस्या: {str(e)}"
-            history.append([message, error_message])
-            return history, ""
+# CORS middleware - आपके frontend के लिए जरूरी
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Production में specific domains add करें
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
 
-# Initialize AI Assistant
-ai_assistant = AIAssistant()
+# Request models
+class ChatMessage(BaseModel):
+    role: str
+    content: str
 
-# Custom CSS
-custom_css = """
-/* Main container styling */
-.gradio-container {
-    font-family: 'Inter', sans-serif !important;
-    background: linear-gradient(135deg, #FBF9F6 0%, #F7F5F2 100%) !important;
-    min-height: 100vh;
-}
+class ChatRequest(BaseModel):
+    type: str
+    prompt: str
+    model: Optional[str] = "openai"
+    conversation: Optional[List[ChatMessage]] = []
+    stream: Optional[bool] = True
+    private: Optional[bool] = True
+    referrer: Optional[str] = API_KEY
 
-/* Chat interface styling */
-.chat-interface {
-    max-width: 800px;
-    margin: 0 auto;
-}
+class ChatResponse(BaseModel):
+    success: bool
+    choices: Optional[List[Dict]] = None
+    error: Optional[str] = None
+    model: Optional[str] = None
+    timestamp: Optional[int] = None
 
-/* Button styling */
-.submit-btn {
-    background: linear-gradient(135deg, #D97757 0%, #B85C42 100%) !important;
-    color: white !important;
-    border: none !important;
-    border-radius: 0.75rem !important;
-    font-weight: 600 !important;
-}
+@app.get("/")
+async def root():
+    """Health check endpoint"""
+    return {
+        "status": "running",
+        "message": "AI Assistant API Server",
+        "timestamp": int(time.time())
+    }
 
-.submit-btn:hover {
-    transform: translateY(-2px) !important;
-    box-shadow: 0 8px 25px rgba(217, 119, 87, 0.3) !important;
-}
-"""
+@app.post("/api/chat")
+async def chat_endpoint(request: ChatRequest):
+    """Main chat endpoint - exactly like your server.php"""
+    
+    if not request.prompt or not request.prompt.strip():
+        raise HTTPException(status_code=400, detail="Prompt cannot be empty")
+    
+    try:
+        if request.stream:
+            return StreamingResponse(
+                generate_streaming_response(request),
+                media_type="text/event-stream",
+                headers={
+                    "Cache-Control": "no-cache",
+                    "Connection": "keep-alive",
+                    "Access-Control-Allow-Origin": "*",
+                    "Access-Control-Allow-Methods": "POST, GET, OPTIONS",
+                    "Access-Control-Allow-Headers": "Content-Type"
+                }
+            )
+        else:
+            response = await generate_non_streaming_response(request)
+            return response
+            
+    except Exception as e:
+        logger.error(f"Chat error: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Server error: {str(e)}")
 
-# Create Gradio Interface
-with gr.Blocks(
-    theme=gr.themes.Soft(
-        primary_hue="orange",
-        secondary_hue="amber",
-        neutral_hue="stone"
-    ),
-    css=custom_css,
-    title="AI Assistant - Powered by Pollinations"
-) as demo:
+async def generate_streaming_response(request: ChatRequest):
+    """Generate streaming response - exactly like your PHP version"""
     
-    # Header
-    gr.HTML("""
-    <div style="text-align: center; padding: 2rem 0; background: rgba(255, 255, 255, 0.8); border-radius: 1rem; margin-bottom: 2rem; backdrop-filter: blur(10px);">
-        <div style="display: flex; align-items: center; justify-content: center; gap: 1rem;">
-            <svg width="48" height="48" viewBox="0 0 100 100">
-                <path d="M50 0 L61.8 38.2 L100 38.2 L69.1 61.8 L80.9 100 L50 76.4 L19.1 100 L30.9 61.8 L0 38.2 L38.2 38.2 Z" fill="#D97757"/>
-            </svg>
-            <h1 style="font-size: 2.5rem; font-weight: 600; color: #3D3D3D; margin: 0; font-family: 'Playfair Display', serif;">
-                Hi, कैसे मदद कर सकता हूँ?
-            </h1>
-        </div>
-        <p style="color: #8B7355; margin-top: 0.5rem; font-size: 1.1rem;">
-            आपका AI Assistant - Hindi और English में बातचीत के लिए तैयार
-        </p>
-    </div>
-    """)
+    # System message
+    system_message = {
+        'role': 'system',
+        'content': 'आप एक helpful AI assistant हैं। User को Hindi और English दोनों languages में helpful और accurate answers देते हैं। आप friendly, conversational और natural tone में बात करते हैं। Code माँगने पर proper formatting के साथ दें। हमेशा relevant और उपयोगी जवाब दें।'
+    }
     
-    # Main Chat Interface
-    with gr.Column():
-        # Fixed Chatbot with proper parameters
-        chatbot = gr.Chatbot(
-            value=[],
-            height=500,
-            show_label=False,
-            avatar_images=("👤", "🤖"),
-            show_share_button=False,
-            show_copy_button=True,
-            type="tuples"  # Explicitly set type to avoid warning
-        )
-        
-        with gr.Row():
-            with gr.Column(scale=8):
-                msg = gr.Textbox(
-                    placeholder="मुझसे कुछ भी पूछें... (Hindi या English में)",
-                    show_label=False,
-                    container=False,
-                    lines=1,
-                    max_lines=5
-                )
-            with gr.Column(scale=1, min_width=80):
-                submit = gr.Button(
-                    "भेजें ➤",
-                    variant="primary"
-                )
-        
-        # Example prompts - Fixed without elem_classes
-        with gr.Row():
-            with gr.Column():
-                gr.Markdown("**कुछ सुझाव:**")
-                example_buttons = []
-                examples = [
-                    "एक कविता लिखकर दो",
-                    "Python में calculator बनाना सिखाएं", 
-                    "मुझसे बात करिए",
-                    "What is machine learning?",
-                    "भारत का इतिहास बताएं",
-                    "कोई मजेदार fact बताएं"
-                ]
+    messages = [system_message]
+    
+    # Add conversation history
+    for msg in request.conversation[-MAX_CONTEXT_MESSAGES:]:
+        if msg.role in ['user', 'assistant'] and msg.content.strip():
+            content = msg.content[:2000]  # Limit content length
+            messages.append({
+                'role': msg.role,
+                'content': content
+            })
+    
+    # Add current prompt
+    messages.append({
+        'role': 'user',
+        'content': request.prompt
+    })
+    
+    payload = {
+        'model': request.model,
+        'messages': messages,
+        'temperature': 0.7,
+        'max_tokens': 1000,
+        'top_p': 0.9,
+        'stream': True,
+        'private': request.private,
+        'referrer': request.referrer,
+        'seed': int(time.time()) % 1000000
+    }
+    
+    try:
+        async with aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=60)) as session:
+            async with session.post(
+                POLLINATIONS_API_URL,
+                json=payload,
+                headers={
+                    'Content-Type': 'application/json',
+                    'Accept': 'text/event-stream',
+                    'User-Agent': 'AI-Assistant-API/1.0'
+                }
+            ) as response:
+                
+                if response.status != 200:
+                    error_text = await response.text()
+                    yield f"data: {json.dumps({'error': f'API returned HTTP {response.status}: {error_text}'})}\n\n"
+                    return
                 
-                # Create example buttons manually
-                with gr.Row():
-                    for i, example in enumerate(examples[:3]):
-                        btn = gr.Button(example, size="sm", variant="secondary")
-                        example_buttons.append(btn)
-                        btn.click(lambda x=example: x, outputs=msg)
+                async for line in response.content:
+                    line_text = line.decode('utf-8')
+                    yield line_text
                 
-                with gr.Row():
-                    for i, example in enumerate(examples[3:]):
-                        btn = gr.Button(example, size="sm", variant="secondary")
-                        example_buttons.append(btn)
-                        btn.click(lambda x=example: x, outputs=msg)
+                yield "data: [DONE]\n\n"
+                
+    except asyncio.TimeoutError:
+        yield f"data: {json.dumps({'error': 'Request timeout - कृपया दो���ारा कोशिश करें'})}\n\n"
+    except Exception as e:
+        yield f"data: {json.dumps({'error': f'Network error: {str(e)}'})}\n\n"
+
+async def generate_non_streaming_response(request: ChatRequest):
+    """Generate non-streaming response"""
+    
+    system_message = {
+        'role': 'system',
+        'content': 'आप एक helpful AI assistant हैं। User को Hindi और English दोनों languages में helpful और accurate answers देते हैं। आप friendly, conversational और natural tone में बात करते हैं। Code माँगने पर proper formatting के साथ दें। हमेशा relevant और उपयोगी जवाब दें।'
+    }
+    
+    messages = [system_message]
+    
+    for msg in request.conversation[-MAX_CONTEXT_MESSAGES:]:
+        if msg.role in ['user', 'assistant'] and msg.content.strip():
+            content = msg.content[:2000]
+            messages.append({
+                'role': msg.role,
+                'content': content
+            })
+    
+    messages.append({
+        'role': 'user',
+        'content': request.prompt
+    })
     
-    # Footer
-    gr.HTML("""
-    <div style="text-align: center; padding: 1rem; color: #8B7355; font-size: 0.875rem; border-top: 1px solid #EAE8E5; background: rgba(255, 255, 255, 0.5);">
-        <p>🔒 Powered by <strong>Pollinations AI</strong> | 🌟 Built with Gradio on Hugging Face Spaces</p>
-        <p style="font-size: 0.75rem; margin-top: 0.5rem;">
-            यह AI assistant आपकी बातचीत को याद रखता है और context के साथ जवाब देता है
-        </p>
-    </div>
-    """)
+    payload = {
+        'model': request.model,
+        'messages': messages,
+        'temperature': 0.7,
+        'max_tokens': 1000,
+        'top_p': 0.9,
+        'stream': False,
+        'private': request.private,
+        'referrer': request.referrer,
+        'seed': int(time.time()) % 1000000
+    }
     
-    # Event handlers
-    msg.submit(ai_assistant.chat_response, [msg, chatbot], [chatbot, msg])
-    submit.click(ai_assistant.chat_response, [msg, chatbot], [chatbot, msg])
+    try:
+        async with aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=30)) as session:
+            async with session.post(
+                POLLINATIONS_API_URL,
+                json=payload,
+                headers={
+                    'Content-Type': 'application/json',
+                    'User-Agent': 'AI-Assistant-API/1.0'
+                }
+            ) as response:
+                
+                if response.status != 200:
+                    error_text = await response.text()
+                    return ChatResponse(
+                        success=False,
+                        error=f"API returned HTTP {response.status}: {error_text}"
+                    )
+                
+                data = await response.json()
+                
+                return ChatResponse(
+                    success=True,
+                    choices=data.get('choices', []),
+                    model=request.model,
+                    timestamp=int(time.time())
+                )
+                
+    except Exception as e:
+        logger.error(f"API Error: {str(e)}")
+        return ChatResponse(
+            success=False,
+            error=f"Network error: {str(e)}"
+        )
+
+# Health check endpoints
+@app.get("/health")
+async def health_check():
+    return {"status": "healthy", "timestamp": int(time.time())}
+
+@app.get("/api/status")
+async def api_status():
+    return {
+        "api_version": "1.0.0",
+        "pollinations_endpoint": POLLINATIONS_API_URL,
+        "max_context_messages": MAX_CONTEXT_MESSAGES,
+        "supported_models": ["openai"],
+        "timestamp": int(time.time())
+    }
 
-# Launch configuration
 if __name__ == "__main__":
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=False,
-        debug=False,
-        show_error=True,
-        quiet=False
-    )
+    uvicorn.run(app, host="0.0.0.0", port=7860)