Update app.py

app.py

@@ -1,377 +1,272 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-import sys
-import asyncio
-
-# تأكد من أنك تستخدم Python 3.10+
-if sys.version_info < (3, 10):
-    print("❌ Python 3.10 or higher is required")
-    sys.exit(1)
-
-# باقي الاستيرادات هنا...
-from fastapi import FastAPI, Request, HTTPException
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import StreamingResponse, JSONResponse
-from pydantic import BaseModel
-from typing import List, Optional
-import json
 import time
-import uuid
+import random
+import traceback
 import logging
 
-# محاولة استيراد g4f مع معالجة الأخطاء
-try:
-    from g4f.client import Client
-    from g4f import Provider
-    print("✅ g4f imported successfully")
-except ImportError as e:
-    print(f"❌ Failed to import g4f: {e}")
-    print("📦 Installing required packages...")
-    import subprocess
-    subprocess.check_call([sys.executable, "-m", "pip", "install", "--upgrade", "g4f"])
-    from g4f.client import Client
-    from g4f import Provider
+from fastapi import FastAPI, HTTPException, Request
+from pydantic import BaseModel
+import uvicorn
 
-# =====================================================
-# LOGGING
-# =====================================================
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger("gateway")
+from g4f.client import Client
+from g4f.Provider import __providers__
 
 # =====================================================
 # CONFIG
 # =====================================================
+
 API_KEY = "sk-your-secret-key"
-STREAM_TIMEOUT = 90
-REQUEST_TIMEOUT = 45
 
-# =====================================================
-# FASTAPI
-# =====================================================
-app = FastAPI(
-    title="Universal AI Gateway",
-    version="10.1"
-)
+MODEL = "gpt-4o-mini"
+
+MAX_RETRIES = 10
+TIMEOUT = 60
 
 # =====================================================
-# CORS
+# LOGGING
 # =====================================================
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(message)s"
 )
 
+logger = logging.getLogger("smart-g4f")
+
 # =====================================================
-# MODELS
+# FASTAPI
 # =====================================================
-SUPPORTED_MODELS = [
-    "gpt-4o-mini",
-    "gpt-3.5-turbo",
-    "blackboxai",
-    "copilot",
-]
-
-# مزودين مستقرين
-STABLE_PROVIDERS = [
-    (Provider.Copilot, "copilot"),
-    (Provider.DuckDuckGo, "gpt-4o-mini"),
-    (Provider.Blackbox, "blackboxai"),
-]
-
-class Message(BaseModel):
-    role: str
-    content: str
 
-class ChatRequest(BaseModel):
-    model: str = "gpt-4o-mini"
-    messages: List[Message]
-    stream: bool = False
-    temperature: Optional[float] = 0.7
-    max_tokens: Optional[int] = 4096
+app = FastAPI(
+    title="Smart G4F Gateway",
+    version="1.1"
+)
 
 # =====================================================
 # AUTH
 # =====================================================
+
 def verify_api_key(req: Request):
+
     auth = req.headers.get("Authorization")
+
     if not auth:
-        raise HTTPException(status_code=401, detail="Missing Authorization Header")
+        raise HTTPException(
+            status_code=401,
+            detail="Missing Authorization Header"
+        )
+
     if not auth.startswith("Bearer "):
-        raise HTTPException(status_code=401, detail="Invalid Authorization Format")
+        raise HTTPException(
+            status_code=401,
+            detail="Invalid Authorization Format"
+        )
+
     token = auth.replace("Bearer ", "").strip()
+
     if token != API_KEY:
-        raise HTTPException(status_code=403, detail="Invalid API Key")
+        raise HTTPException(
+            status_code=403,
+            detail="Invalid API Key"
+        )
 
 # =====================================================
-# معالج الـ chunks العالمي
+# SAFE PROVIDERS
 # =====================================================
-def extract_content_from_chunk(chunk) -> Optional[str]:
-    if not chunk:
-        return None
-    
-    if isinstance(chunk, str):
-        return chunk if chunk.strip() else None
-    
-    if hasattr(chunk, 'choices') and chunk.choices:
-        try:
-            if hasattr(chunk.choices[0], 'delta') and chunk.choices[0].delta:
-                content = chunk.choices[0].delta.content
-                if content:
-                    return content
-            if hasattr(chunk.choices[0], 'message') and chunk.choices[0].message:
-                content = chunk.choices[0].message.content
-                if content:
-                    return content
-        except:
-            pass
-    
-    try:
-        if isinstance(chunk, dict) and 'choices' in chunk:
-            return chunk['choices'][0].get('delta', {}).get('content', '')
-    except:
-        pass
-    
+
+SAFE_PROVIDERS = []
+
+for provider in __providers__:
+
     try:
-        text = str(chunk)
-        if text and text not in ['', 'None', 'null']:
-            return text
-    except:
-        pass
-    
-    return None
+
+        name = provider.__name__.lower()
+
+        if not getattr(provider, "working", False):
+            continue
+
+        if getattr(provider, "needs_auth", False):
+            continue
+
+        if getattr(provider, "use_nodriver", False):
+            continue
+
+        blocked = [
+            "openai",
+            "qwen",
+            "copilot",
+            "gemini",
+            "claude",
+        ]
+
+        if any(x in name for x in blocked):
+            continue
+
+        SAFE_PROVIDERS.append(provider)
+
+    except Exception:
+        continue
+
+random.shuffle(SAFE_PROVIDERS)
+
+logger.info(f"[+] SAFE PROVIDERS: {len(SAFE_PROVIDERS)}")
+
+client = Client()
 
 # =====================================================
-# STREAMING
+# SMART G4F
 # =====================================================
-async def safe_stream_from_provider(provider, model, messages):
-    client = Client(provider=provider)
-    
-    def sync_stream():
-        return client.chat.completions.create(
-            model=model,
-            messages=messages,
-            stream=True
-        )
-    
-    try:
-        stream = await asyncio.wait_for(
-            asyncio.to_thread(sync_stream),
-            timeout=15.0
-        )
-    except asyncio.TimeoutError:
-        raise Exception("Timeout while initializing stream")
-    except Exception as e:
-        raise Exception(f"Stream initialization error: {e}")
-    
-    async def generator():
-        chunk_count = 0
-        try:
-            async with asyncio.timeout(STREAM_TIMEOUT):
-                for raw_chunk in stream:
-                    chunk_count += 1
-                    content = extract_content_from_chunk(raw_chunk)
-                    if content and content.strip():
-                        yield content.strip()
-                    if chunk_count > 1000:
-                        break
-                    await asyncio.sleep(0.005)
-        except asyncio.TimeoutError:
-            if chunk_count == 0:
-                yield "[Timeout - No response received]"
-        except Exception as e:
-            if chunk_count == 0:
-                yield f"[Error: {str(e)[:50]}]"
-    
-    return generator()
+
+class SmartG4F:
+
+    def __init__(self):
+
+        self.good = []
+        self.bad = {}
+
+    def mark_bad(self, provider, cooldown=300):
+
+        self.bad[provider.__name__] = time.time() + cooldown
+
+    def is_bad(self, provider):
+
+        if provider.__name__ not in self.bad:
+            return False
+
+        return time.time() < self.bad[provider.__name__]
+
+    def get_provider(self):
+
+        random.shuffle(SAFE_PROVIDERS)
+
+        for provider in SAFE_PROVIDERS:
+
+            if self.is_bad(provider):
+                continue
+
+            return provider
+
+        return None
+
+    def ask(self, prompt):
+
+        for _ in range(MAX_RETRIES):
+
+            provider = self.get_provider()
+
+            if not provider:
+                break
+
+            try:
+
+                logger.info(f"[+] Trying: {provider.__name__}")
+
+                response = client.chat.completions.create(
+                    model=MODEL,
+                    provider=provider,
+                    messages=[
+                        {
+                            "role": "user",
+                            "content": prompt
+                        }
+                    ],
+                    timeout=TIMEOUT
+                )
+
+                text = response.choices[0].message.content
+
+                if text:
+
+                    logger.info(f"[+] Success: {provider.__name__}")
+
+                    return {
+                        "provider": provider.__name__,
+                        "response": text
+                    }
+
+            except Exception as e:
+
+                logger.warning(f"[-] Failed: {provider.__name__} -> {e}")
+
+                self.mark_bad(provider)
+
+        raise Exception("All providers failed")
+
+smart = SmartG4F()
 
 # =====================================================
-# NORMAL RESPONSE
+# REQUEST MODEL
 # =====================================================
-async def safe_normal_completion(provider, model, messages):
-    client = Client(provider=provider)
-    
-    def sync_request():
-        return client.chat.completions.create(
-            model=model,
-            messages=messages,
-            stream=False
-        )
-    
-    response = await asyncio.wait_for(
-        asyncio.to_thread(sync_request),
-        timeout=REQUEST_TIMEOUT
-    )
-    
-    try:
-        if hasattr(response, 'choices') and response.choices:
-            content = response.choices[0].message.content
-            if content:
-                return content
-    except:
-        pass
-    
-    return str(response) if response else "No response received"
+
+class ChatRequest(BaseModel):
+
+    prompt: str
 
 # =====================================================
-# ENDPOINTS
+# ROUTES
 # =====================================================
+
 @app.get("/")
+
 async def root():
+
     return {
         "status": "online",
-        "version": "10.1",
-        "auth_required": True,
-        "providers": [p[0].__name__ for p in STABLE_PROVIDERS]
+        "providers": len(SAFE_PROVIDERS),
+        "model": MODEL
     }
 
-@app.get("/v1/models")
-async def models():
+@app.get("/health")
+
+async def health():
+
     return {
-        "object": "list",
-        "data": [
-            {"id": m, "object": "model", "created": int(time.time()), "owned_by": "g4f"}
-            for m in SUPPORTED_MODELS
-        ]
+        "ok": True
     }
 
-@app.post("/v1/chat/completions")
-async def chat_completions(req: Request, body: ChatRequest):
+@app.post("/chat")
+
+async def chat(req: Request, body: ChatRequest):
+
     verify_api_key(req)
-    
-    if body.model not in SUPPORTED_MODELS:
-        body.model = "gpt-4o-mini"
-    
-    messages = [{"role": m.role, "content": m.content} for m in body.messages]
-    
-    if body.stream:
-        async def generate():
-            chunk_id = f"chatcmpl-{uuid.uuid4().hex[:8]}"
-            
-            for provider, provider_model in STABLE_PROVIDERS:
-                try:
-                    stream_gen = await safe_stream_from_provider(provider, body.model, messages)
-                    content_received = False
-                    
-                    async for content in stream_gen:
-                        if content:
-                            content_received = True
-                            payload = {
-                                "id": chunk_id,
-                                "object": "chat.completion.chunk",
-                                "created": int(time.time()),
-                                "model": body.model,
-                                "choices": [{
-                                    "index": 0,
-                                    "delta": {"content": content},
-                                    "finish_reason": None
-                                }]
-                            }
-                            yield f"data: {json.dumps(payload)}\n\n"
-                            await asyncio.sleep(0.01)
-                    
-                    if content_received:
-                        yield f"data: {json.dumps({
-                            'id': chunk_id, 'object': 'chat.completion.chunk',
-                            'created': int(time.time()), 'model': body.model,
-                            'choices': [{'index': 0, 'delta': {}, 'finish_reason': 'stop'}]
-                        })}\n\n"
-                        yield "data: [DONE]\n\n"
-                        return
-                        
-                except Exception as e:
-                    logger.warning(f"{provider.__name__} failed: {e}")
-                    continue
-            
-            yield f"data: {json.dumps({'error': {'message': 'All providers failed', 'type': 'server_error'}})}\n\n"
-        
-        return StreamingResponse(generate(), media_type="text/event-stream")
-    
-    # Non-streaming
-    for provider, provider_model in STABLE_PROVIDERS:
-        try:
-            content = await safe_normal_completion(provider, body.model, messages)
-            if content:
-                return JSONResponse({
-                    "id": f"chatcmpl-{uuid.uuid4().hex[:8]}",
-                    "object": "chat.completion",
-                    "created": int(time.time()),
-                    "model": body.model,
-                    "choices": [{
-                        "index": 0,
-                        "message": {"role": "assistant", "content": content},
-                        "finish_reason": "stop"
-                    }]
-                })
-        except Exception as e:
-            logger.warning(f"{provider.__name__} failed: {e}")
-            continue
-    
-    raise HTTPException(status_code=500, detail="All providers failed")
-
-@app.get("/test")
-async def test_ui():
-    return """
-    <!DOCTYPE html>
-    <html>
-    <head><title>AI Gateway Test</title>
-    <style>
-        body { font-family: Arial; max-width: 800px; margin: 50px auto; }
-        #chat { border: 1px solid #ccc; height: 400px; overflow-y: auto; padding: 10px; }
-        .user { background: #007bff; color: white; padding: 8px; margin: 5px; border-radius: 10px; text-align: right; }
-        .bot { background: #e9ecef; padding: 8px; margin: 5px; border-radius: 10px; }
-        .input-area { display: flex; gap: 10px; margin-top: 10px; }
-        #input { flex: 1; padding: 10px; }
-        #send { padding: 10px 20px; background: #007bff; color: white; border: none; cursor: pointer; }
-    </style>
-    </head>
-    <body>
-        <h2>AI Gateway Test</h2>
-        <div id="chat"></div>
-        <div class="input-area">
-            <input type="text" id="input" placeholder="Type your message...">
-            <button id="send">Send</button>
-        </div>
-        <script>
-            const API_KEY = "sk-your-secret-key";
-            async function send() {
-                const input = document.getElementById('input');
-                const msg = input.value.trim();
-                if (!msg) return;
-                const chat = document.getElementById('chat');
-                chat.innerHTML += `<div class="user">${msg}</div>`;
-                input.value = '';
-                const botDiv = document.createElement('div');
-                botDiv.className = 'bot';
-                botDiv.textContent = 'Thinking...';
-                chat.appendChild(botDiv);
-                try {
-                    const res = await fetch('/v1/chat/completions', {
-                        method: 'POST',
-                        headers: {'Content-Type': 'application/json', 'Authorization': 'Bearer ' + API_KEY},
-                        body: JSON.stringify({model: 'gpt-4o-mini', messages: [{role: 'user', content: msg}]})
-                    });
-                    const data = await res.json();
-                    botDiv.textContent = data.choices[0].message.content;
-                } catch(e) { botDiv.textContent = 'Error: ' + e.message; }
-            }
-            document.getElementById('send').onclick = send;
-            document.getElementById('input').onkeypress = (e) => { if(e.key === 'Enter') send(); };
-        </script>
-    </body>
-    </html>
-    """
+
+    try:
+
+        result = smart.ask(body.prompt)
+
+        return {
+            "success": True,
+            "provider": result["provider"],
+            "response": result["response"]
+        }
+
+    except Exception as e:
+
+        logger.error(traceback.format_exc())
+
+        raise HTTPException(
+            status_code=500,
+            detail=str(e)
+        )
+
+# =====================================================
+# RUN
+# =====================================================
 
 if __name__ == "__main__":
-    import uvicorn
+
     print("""
-    ╔══════════════════════════════════════════╗
-    ║  AI Gateway v10.1 Running 🚀            ║
-    ║  http://localhost:7860/test             ║
-    ║  API Key: sk-your-secret-key            ║
-    ╚══════════════════════════════════════════╝
-    """)
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+╔══════════════════════════════╗
+║      Smart G4F Gateway      ║
+╠══════════════════════════════╣
+║  API KEY ENABLED            ║
+║  MODEL: gpt-4o-mini         ║
+║  /chat                      ║
+║  /health                    ║
+╚══════════════════════════════╝
+""")
+
+    uvicorn.run(
+        app,
+        host="0.0.0.0",
+        port=7860
+    )