Update app.py

app.py

@@ -1,160 +1,227 @@
 import time
 import traceback
 import asyncio
+import logging
+from collections import deque
+from contextlib import asynccontextmanager
+from typing import Optional
 
-from fastapi import FastAPI
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel
 import uvicorn
 
 from g4f.client import Client
 from g4f.Provider import __providers__
 
-# إعدادات محسنة
+# ============ إعدادات محسنة ============
 MODEL = "gpt-4o-mini"
-MAX_RETRIES = 3          # تقليل المحاولات: 3 كافية جداً لتوفير وقت المستخدم
-TIMEOUT = 30             # تقليل وقت الانتظار: 60 ثانية كثيرة جداً وتعطل الخادم
-MAX_CONCURRENT = 5       # أقصى عدد طلبات متوازية (مهم جداً لمنع الرات ليميت الشامل)
+MAX_RETRIES = 3
+TIMEOUT = 30                # timeout لكل طلب منفرد
+GLOBAL_TIMEOUT = 60         # 🆕 timeout إجمالي لكل عملية (يمنع بقاء الطلب معلقاً)
+MAX_CONCURRENT = 5
+GOOD_POOL_SIZE = 10         # 🆕 حجم القائمة المفضلة (dequeue بدلاً من قائمة غير محدودة)
+
+# ============ Logging منظم ============
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s | %(levelname)s | %(message)s",
+    datefmt="%H:%M:%S",
+)
+log = logging.getLogger("g4f-smart")
+
+# ============ تجميع المزودين ============
+BLOCKED_KEYWORDS = ["openai", "qwen", "copilot", "gemini", "claude",
+                    "google", "meta", "tecnai", "liaobots"]
 
-# تجميع المزودين الآمنين
 SAFE_PROVIDERS = []
-BLOCKED_KEYWORDS = ["openai", "qwen", "copilot", "gemini", "claude", "google", "meta", "tecnai", "liaobots"]
-
 for provider in __providers__:
     try:
         if not getattr(provider, "working", False): continue
         if getattr(provider, "needs_auth", False): continue
         if getattr(provider, "use_nodriver", False): continue
-        
         name = provider.__name__.lower()
         if any(x in name for x in BLOCKED_KEYWORDS): continue
-        
         SAFE_PROVIDERS.append(provider)
-    except:
+    except Exception:
         pass
 
-print(f"[+] SAFE PROVIDERS: {len(SAFE_PROVIDERS)}")
-
-client = Client()
+log.info(f"[+] SAFE PROVIDERS: {len(SAFE_PROVIDERS)}")
 
 
 class SmartG4F:
     def __init__(self):
-        self.good = []
-        self.bad = {}           # provider_name: expire_timestamp
-        self.current_index = 0  # مؤشر الدوران المنتظم (Round Robin)
-        self.lock = asyncio.Lock()     # حماية البيانات من التزامن
-        self.semaphore = asyncio.Semaphore(MAX_CONCURRENT) # حماية الخادم من الضغط
-
-    def mark_bad(self, provider, cooldown):
+        self.client = Client()                                # 🆕 داخل الكلاس
+        # 🆕 deque بحد أقصى: القائمة المفضلة لا تنمو إلى ما لا نهاية
+        self.good = deque(maxlen=GOOD_POOL_SIZE)
+        self.bad: dict[str, float] = {}
+        self.current_index = 0
+        self.lock = asyncio.Lock()
+        self.semaphore = asyncio.Semaphore(MAX_CONCURRENT)
+
+    def mark_bad(self, provider, cooldown: float):
         self.bad[provider.__name__] = time.time() + cooldown
 
-    def is_bad(self, provider):
+    def is_bad(self, provider) -> bool:
         expire = self.bad.get(provider.__name__)
-        if not expire: return False
+        if not expire:
+            return False
         if time.time() > expire:
-            del self.bad[provider.__name__]
+            self.bad.pop(provider.__name__, None)
             return False
         return True
 
     async def get_next_provider(self):
         async with self.lock:
-            # بناء حوض المزودين المتاحين في هذه اللحظة
+            # 🆕 pool واحد موحّد: good أولاً ثم SAFE_PROVIDERS
             pool = [p for p in self.good if not self.is_bad(p)]
-            
             for p in SAFE_PROVIDERS:
                 if p not in pool and not self.is_bad(p):
                     pool.append(p)
-            
-            if not pool: return None
-            
-            # 🧠 الذكاء هنا: Round Robin يضمن عدم ضرب نفس المزود مرتين متتاليتين
+
+            if not pool:
+                return None
+
             provider = pool[self.current_index % len(pool)]
             self.current_index += 1
             return provider
 
-    async def ask(self, prompt):
-        errors = []
-        
-        # إجبار الخادم على عدم تجاوز الحد الأقصى للطلبات المتوازية
+    async def _call_provider(self, provider, prompt: str):
+        """دالة مساعدة قابلة للإلغاء مع timeout."""
+        return await asyncio.to_thread(
+            self.client.chat.completions.create,
+            model=MODEL,
+            provider=provider,
+            messages=[{"role": "user", "content": prompt}],
+            timeout=TIMEOUT,
+        )
+
+    async def ask(self, prompt: str) -> dict:
+        errors: list[dict] = []
+
         async with self.semaphore:
-            for attempt in range(MAX_RETRIES):
-                provider = await self.get_next_provider()
-                
-                if not provider:
-                    return {"success": False, "error": "All providers are currently on cooldown. Try again later."}
-                
-                print(f"[TRY {attempt+1}] {provider.__name__}")
-                
-                try:
-                    # تشغيل الكود المتزامن (sync) في Thread منفصل لئلا يعلق الـ FastAPI
-                    response = await asyncio.to_thread(
-                        client.chat.completions.create,
-                        model=MODEL,
-                        provider=provider,
-                        messages=[{"role": "user", "content": prompt}],
-                        timeout=TIMEOUT,
-                    )
-                    
-                    text = response.choices[0].message.content
-                    
-                    if not text:
-                        raise Exception("Empty response")
-                    
-                    # إضافة المزود الناجح للقائمة المفضلة
-                    async with self.lock:
-                        if provider not in self.good:
-                            self.good.append(provider)
-                    
-                    return {
-                        "success": True,
-                        "provider": provider.__name__,
-                        "response": text
-                    }
-                
-                except Exception as e:
-                    err = str(e).lower()
-                    traceback.print_exc()
-                    
-                    errors.append({
-                        "provider": provider.__name__,
-                        "error": str(e)
-                    })
-                    
-                    async with self.lock:
-                        # 🧠 فترات تبريد ذكية: قصيرة لأن الرات ليميت المجاني يزول بسرعة
-                        if "429" in err:
-                            # 60 ثانية كافية لزوال الرات ليميت، وليس 10 دقائق!
-                            self.mark_bad(provider, 60)
-                        elif "cloudflare" in err:
-                            self.mark_bad(provider, 300) # 5 دقائق
-                        elif "timeout" in err:
-                            self.mark_bad(provider, 120)  # دقيقتان
-                        else:
-                            self.mark_bad(provider, 60)   # دقيقة واحدة فقط
-                    
-                    # ننتقل للمزود التالي فوراً بدون إيقاف الخادم (تم حذف time.sleep)
-                    continue
-
-        return {"success": False, "errors": errors}
-
-# إعداد FastAPI
-app = FastAPI()
-ai = SmartG4F()
+            # 🆕 حماية من التعليق الكلي
+            try:
+                async with asyncio.timeout(GLOBAL_TIMEOUT):
+                    for attempt in range(MAX_RETRIES):
+                        provider = await self.get_next_provider()
+                        if not provider:
+                            return {
+                                "success": False,
+                                "error": "All providers are currently on cooldown."
+                            }
+
+                        log.info(f"[TRY {attempt+1}/{MAX_RETRIES}] {provider.__name__}")
+
+                        try:
+                            response = await self._call_provider(provider, prompt)
+                            text = response.choices[0].message.content
+
+                            if not text:
+                                raise ValueError("Empty response")
+
+                            async with self.lock:
+                                # 🆕 deque تحافظ على الحجم ثابتاً تلقائياً
+                                if provider in self.good:
+                                    self.good.remove(provider)
+                                self.good.appendleft(provider)  # الأحدث في الأول
+
+                            return {
+                                "success": True,
+                                "provider": provider.__name__,
+                                "response": text,
+                            }
+
+                        except asyncio.CancelledError:
+                            raise
+                        except Exception as e:
+                            err = str(e).lower()
+                            log.warning(f"{provider.__name__} failed: {e}")
+
+                            errors.append({
+                                "provider": provider.__name__,
+                                "error": str(e),
+                            })
+
+                            # 🆕 تصنيف ذكي للأخطاء
+                            if "429" in err or "rate" in err:
+                                self.mark_bad(provider, 60)
+                            elif "cloudflare" in err:
+                                self.mark_bad(provider, 300)
+                            elif "timeout" in err:
+                                self.mark_bad(provider, 120)
+                            elif "403" in err or "forbidden" in err:
+                                self.mark_bad(provider, 600)
+                            else:
+                                self.mark_bad(provider, 60)
+            except TimeoutError:
+                log.error("Global timeout reached")
+                errors.append({"stage": "global", "error": "Global timeout"})
+
+        # 🆕 إرجاع آخر خطأ فقط عند الفشل لتقليل حجم الرد
+        last_error = errors[-1] if errors else {"error": "Unknown"}
+        return {
+            "success": False,
+            "attempts": len(errors),
+            "last_error": last_error,
+            "errors": errors,  # اختياري: يمكن حذفها
+        }
+
+
+# ============ إعداد FastAPI ============
+@asynccontextmanager
+async def lifespan(_: FastAPI):
+    ai = SmartG4F()
+    app.state.ai = ai
+    log.info("Server started")
+    yield
+    log.info("Server shutting down")
+
+
+app = FastAPI(title="Smart G4F", lifespan=lifespan)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
 
 class Query(BaseModel):
     prompt: str
+    model: Optional[str] = None
+
 
 @app.get("/")
 async def home():
+    ai: SmartG4F = app.state.ai
     return {
         "status": "running",
         "safe_providers": len(SAFE_PROVIDERS),
-        "healthy_providers": len(ai.good)
+        "healthy_providers": len(ai.good),
+        "cooldown_providers": len(ai.bad),
+    }
+
+
+@app.get("/health")
+async def health():
+    ai: SmartG4F = app.state.ai
+    return {
+        "providers_available": sum(
+            1 for p in SAFE_PROVIDERS if not ai.is_bad(p)
+        ),
+        "total": len(SAFE_PROVIDERS),
     }
 
+
 @app.post("/ask")
 async def ask(query: Query):
+    if not query.prompt.strip():
+        raise HTTPException(status_code=400, detail="Prompt cannot be empty")
+    ai: SmartG4F = app.state.ai
     return await ai.ask(query.prompt)
 
+
 if __name__ == "__main__":
     uvicorn.run(app, host="0.0.0.0", port=7860)