Update app.py

app.py

@@ -2,251 +2,38 @@ 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, Dict
-
+from typing import List, Optional
 import asyncio
 import json
 import time
 import uuid
 import logging
-import random
-import httpx
-import g4f
 
+import g4f
 from g4f.client import Client
-from g4f import Provider
-
 
 # =====================================================
 # LOGGING
 # =====================================================
 
-logging.basicConfig(
-    level=logging.INFO,
-    format="%(asctime)s [%(levelname)s] %(message)s"
-)
-
+logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-
 # =====================================================
 # CONFIG
 # =====================================================
 
 API_KEY = "sk-your-secret-key"
 
-
-# =====================================================
-# PROXY CONFIG
-# =====================================================
-
-# قائمة البروكسيات - أضف بروكسياتك هنا
-PROXY_LIST = [
-    # "http://user:pass@proxy1:port",
-    # "http://user:pass@proxy2:port",
-    # "socks5://user:pass@proxy3:port",
-]
-
-# بروكسي واحد إذا كان لديك
-SINGLE_PROXY = None
-
-# مثال:
-# "http://user:pass@host:port"
-
-
-# =====================================================
-# PROVIDER SAFE LOADER
-# =====================================================
-
-def safe_provider(name: str):
-    """
-    تحميل المزود إذا كان موجود داخل g4f
-    """
-
-    if hasattr(Provider, name):
-        return getattr(Provider, name)
-
-    logger.warning(f"Provider not found: {name}")
-
-    return None
-
-
-# =====================================================
-# PROVIDERS
-# =====================================================
-
-BLACKBOX = safe_provider("Blackbox")
-LIAOBOTS = safe_provider("Liaobots")
-OPENAICHAT = safe_provider("OpenaiChat")
-DDG = safe_provider("DDG")
-DEEPINFRA = safe_provider("DeepInfra")
-CLOUDFLARE = safe_provider("Cloudflare")
-
-
-# =====================================================
-# PROVIDER MAP - ربط النماذج بمزوديها
-# =====================================================
-
-MODEL_PROVIDER_MAP: Dict[str, list] = {
-
-    # GPT Models
-    "gpt-4o": [
-        p for p in [
-            BLACKBOX,
-            LIAOBOTS,
-            OPENAICHAT
-        ] if p
-    ],
-
-    "gpt-4o-mini": [
-        p for p in [
-            BLACKBOX,
-            DDG,
-            LIAOBOTS,
-            OPENAICHAT
-        ] if p
-    ],
-
-    "gpt-4": [
-        p for p in [
-            BLACKBOX,
-            LIAOBOTS,
-            OPENAICHAT
-        ] if p
-    ],
-
-    "gpt-3.5-turbo": [
-        p for p in [
-            DDG,
-            BLACKBOX,
-            OPENAICHAT
-        ] if p
-    ],
-
-    # Claude Models
-    "claude-3-haiku": [
-        p for p in [
-            DDG,
-            BLACKBOX
-        ] if p
-    ],
-
-    "claude-3-5-sonnet": [
-        p for p in [
-            BLACKBOX,
-            LIAOBOTS
-        ] if p
-    ],
-
-    "claude-3-opus": [
-        p for p in [
-            LIAOBOTS,
-            BLACKBOX
-        ] if p
-    ],
-
-    # Llama Models
-    "llama-3.1-70b": [
-        p for p in [
-            BLACKBOX,
-            DEEPINFRA,
-            CLOUDFLARE
-        ] if p
-    ],
-
-    "llama-3.1-8b": [
-        p for p in [
-            CLOUDFLARE,
-            DEEPINFRA
-        ] if p
-    ],
-
-    "llama-3.2-90b": [
-        p for p in [
-            BLACKBOX,
-            DEEPINFRA
-        ] if p
-    ],
-
-    # Mixtral Models
-    "mixtral-8x7b": [
-        p for p in [
-            DEEPINFRA,
-            BLACKBOX
-        ] if p
-    ],
-
-    # Deepseek Models
-    "deepseek-chat": [
-        p for p in [
-            DEEPINFRA,
-            BLACKBOX
-        ] if p
-    ],
-
-    "deepseek-v3": [
-        p for p in [
-            BLACKBOX,
-            DEEPINFRA
-        ] if p
-    ],
-
-    # Gemini Models
-    "gemini-pro": [
-        p for p in [
-            BLACKBOX,
-            LIAOBOTS
-        ] if p
-    ],
-
-    "gemini-1.5-pro": [
-        p for p in [
-            BLACKBOX,
-            LIAOBOTS
-        ] if p
-    ],
-
-    # Qwen Models
-    "qwen-2.5-72b": [
-        p for p in [
-            BLACKBOX,
-            DEEPINFRA
-        ] if p
-    ],
-
-    # Default fallback
-    "default": [
-        p for p in [
-            BLACKBOX,
-            DDG,
-            DEEPINFRA
-        ] if p
-    ],
-}
-
-
-# =====================================================
-# FALLBACK MODELS - إذا فشل النموذج المطلوب
-# =====================================================
-
-FALLBACK_MODELS = [
-    "gpt-4o-mini",
-    "gpt-3.5-turbo",
-    "llama-3.1-70b",
-]
-
-
 # =====================================================
 # FASTAPI
 # =====================================================
 
 app = FastAPI(
     title="Universal AI Gateway",
-    description="بوابة ذكاء اصطناعي شاملة مع دعم البروكسي",
-    version="5.0.0"
+    version="4.0.0"
 )
 
-
 # =====================================================
 # CORS
 # =====================================================
@@ -259,7 +46,6 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-
 # =====================================================
 # MODELS
 # =====================================================
@@ -268,7 +54,6 @@ class Message(BaseModel):
     role: str
     content: str
 
-
 class ChatRequest(BaseModel):
     model: str
     messages: List[Message]
@@ -276,74 +61,22 @@ class ChatRequest(BaseModel):
     temperature: Optional[float] = 0.7
     max_tokens: Optional[int] = 4096
 
-
-# =====================================================
-# PROXY HELPER
-# =====================================================
-
-def get_proxy() -> Optional[str]:
-    """الحصول على بروكسي من القائمة"""
-
-    if SINGLE_PROXY:
-        logger.info(f"Using single proxy: {SINGLE_PROXY[:20]}...")
-        return SINGLE_PROXY
-
-    if PROXY_LIST:
-        proxy = random.choice(PROXY_LIST)
-        logger.info(f"Using proxy from list: {proxy[:20]}...")
-        return proxy
-
-    return None
-
-
-def get_g4f_proxy_config() -> dict:
-    """إعداد البروكسي لـ g4f"""
-
-    proxy = get_proxy()
-
-    if proxy:
-        return {"proxy": proxy}
-
-    return {}
-
-
-# =====================================================
-# CLIENT BUILDER
-# =====================================================
-
-def build_client(proxy: Optional[str] = None) -> Client:
-    """بناء عميل g4f مع البروكسي"""
-
-    proxy_url = proxy or get_proxy()
-
-    if proxy_url:
-        try:
-            client = Client(proxies=proxy_url)
-            logger.info("Client created with proxy")
-            return client
-
-        except Exception as e:
-            logger.warning(f"Failed to create client with proxy: {e}")
-
-    return Client()
-
-
 # =====================================================
 # AUTH
 # =====================================================
 
 def verify_api_key(req: Request):
-    """التحقق من مفتاح API"""
 
     auth = req.headers.get("Authorization")
 
+    # السماح للاختبار
     if not auth:
         return True
 
     if not auth.startswith("Bearer "):
         raise HTTPException(
             status_code=401,
-            detail="Invalid Authorization Format - يجب أن يبدأ بـ Bearer"
+            detail="Invalid Authorization Format"
         )
 
     token = auth.replace("Bearer ", "").strip()
@@ -351,172 +84,11 @@ def verify_api_key(req: Request):
     if token != API_KEY:
         raise HTTPException(
             status_code=403,
-            detail="Invalid API Key - مفتاح API غير صحيح"
+            detail="Invalid API Key"
         )
 
     return True
 
-
-# =====================================================
-# CORE: SMART COMPLETION WITH RETRY + FALLBACK
-# =====================================================
-
-async def smart_completion(
-    model: str,
-    messages: list,
-    stream: bool = False,
-    max_retries: int = 3,
-    proxy: Optional[str] = None
-):
-
-    providers = MODEL_PROVIDER_MAP.get(
-        model,
-        MODEL_PROVIDER_MAP["default"]
-    )
-
-    providers_shuffled = providers.copy()
-    random.shuffle(providers_shuffled)
-
-    last_error = None
-
-    for attempt in range(max_retries):
-
-        for provider in providers_shuffled:
-
-            try:
-                logger.info(
-                    f"Attempt {attempt+1} | Model: {model} | Provider: {provider.__name__}"
-                )
-
-                client = build_client(proxy)
-
-                proxy_config = get_g4f_proxy_config()
-
-                response = await asyncio.to_thread(
-                    client.chat.completions.create,
-                    model=model,
-                    messages=messages,
-                    provider=provider,
-                    stream=stream,
-                    **proxy_config
-                )
-
-                logger.info(
-                    f"SUCCESS | Model: {model} | Provider: {provider.__name__}"
-                )
-
-                return response, model
-
-            except Exception as e:
-
-                last_error = e
-
-                logger.warning(
-                    f"FAILED | Model: {model} | Provider: {provider.__name__} | Error: {str(e)[:100]}"
-                )
-
-                await asyncio.sleep(0.5)
-
-        if attempt < max_retries - 1:
-
-            wait_time = (attempt + 1) * 1.5
-
-            logger.info(
-                f"Waiting {wait_time}s before retry..."
-            )
-
-            await asyncio.sleep(wait_time)
-
-    # =================================================
-    # FALLBACK MODELS
-    # =================================================
-
-    logger.warning(
-        f"All providers failed for {model}"
-    )
-
-    for fallback_model in FALLBACK_MODELS:
-
-        if fallback_model == model:
-            continue
-
-        fallback_providers = MODEL_PROVIDER_MAP.get(
-            fallback_model,
-            MODEL_PROVIDER_MAP["default"]
-        )
-
-        for fb_provider in fallback_providers[:2]:
-
-            try:
-                logger.info(
-                    f"Fallback => {fallback_model} | Provider => {fb_provider.__name__}"
-                )
-
-                client = build_client(proxy)
-
-                proxy_config = get_g4f_proxy_config()
-
-                response = await asyncio.to_thread(
-                    client.chat.completions.create,
-                    model=fallback_model,
-                    messages=messages,
-                    provider=fb_provider,
-                    stream=stream,
-                    **proxy_config
-                )
-
-                logger.info(
-                    f"Fallback Success => {fallback_model}"
-                )
-
-                return response, fallback_model
-
-            except Exception as e:
-
-                logger.warning(
-                    f"Fallback Failed => {fallback_model} | {str(e)[:100]}"
-                )
-
-                await asyncio.sleep(0.3)
-
-    # =================================================
-    # LAST ATTEMPT
-    # =================================================
-
-    try:
-
-        logger.info(
-            f"Last attempt without provider => {model}"
-        )
-
-        client = build_client(proxy)
-
-        response = await asyncio.to_thread(
-            client.chat.completions.create,
-            model=model,
-            messages=messages,
-            stream=stream
-        )
-
-        return response, model
-
-    except Exception as e:
-
-        last_error = e
-
-        logger.error(f"All attempts failed => {e}")
-
-    raise HTTPException(
-        status_code=503,
-        detail={
-            "error": "All providers failed",
-            "message": str(last_error),
-            "model_requested": model,
-            "suggestion": "Try another model"
-        }
-    )
-
-
 # =====================================================
 # ROOT
 # =====================================================
@@ -527,61 +99,11 @@ async def root():
     return {
         "status": "online",
         "service": "Universal AI Gateway",
-        "version": "5.0.0",
-        "proxy_enabled": bool(PROXY_LIST or SINGLE_PROXY),
-        "supported_models": list(MODEL_PROVIDER_MAP.keys())
+        "version": "4.0.0"
     }
 
-
-# =====================================================
-# HEALTH CHECK
 # =====================================================
-
-@app.get("/health")
-async def health_check():
-
-    proxy_status = "disabled"
-
-    if SINGLE_PROXY or PROXY_LIST:
-
-        proxy_status = "enabled"
-
-        proxy = get_proxy()
-
-        if proxy:
-
-            try:
-
-                async with httpx.AsyncClient(
-                    proxies=proxy,
-                    timeout=10
-                ) as client:
-
-                    resp = await client.get(
-                        "https://api.ipify.org?format=json"
-                    )
-
-                    ip_data = resp.json()
-
-                    proxy_status = (
-                        f"working - IP: {ip_data.get('ip', 'unknown')}"
-                    )
-
-            except Exception as e:
-
-                proxy_status = f"error - {str(e)[:50]}"
-
-    return {
-        "status": "healthy",
-        "timestamp": int(time.time()),
-        "proxy": proxy_status,
-        "providers_count": len(MODEL_PROVIDER_MAP),
-        "fallback_models": FALLBACK_MODELS
-    }
-
-
-# =====================================================
-# MODELS LIST
+# MODELS
 # =====================================================
 
 @app.get("/v1/models")
@@ -589,23 +111,17 @@ async def get_models():
 
     models_data = []
 
-    for model_id in MODEL_PROVIDER_MAP.keys():
-
-        if model_id == "default":
-            continue
-
-        providers_count = len(MODEL_PROVIDER_MAP[model_id])
-
-        models_data.append({
-            "id": model_id,
-            "object": "model",
-            "created": int(time.time()),
-            "owned_by": "g4f",
-            "providers_available": providers_count,
-            "permission": [],
-            "root": model_id,
-            "parent": None
-        })
+    fallback_models = [
+        "gpt-4o-mini",
+        "gpt-4o",
+        "gpt-4",
+        "gpt-3.5-turbo",
+        "claude-3-haiku",
+        "llama-3.1-70b",
+        "mixtral-8x7b",
+        "deepseek-chat",
+        "gemini-pro"
+    ]
 
     try:
 
@@ -613,43 +129,36 @@ async def get_models():
 
             all_models = list(g4f.models._all_models)
 
-            existing_ids = {
-                m["id"]
-                for m in models_data
-            }
-
-            for model in all_models[:30]:
+            for model in all_models[:50]:
 
-                model_str = str(model)
+                models_data.append({
+                    "id": str(model),
+                    "object": "model",
+                    "created": int(time.time()),
+                    "owned_by": "g4f"
+                })
 
-                if model_str not in existing_ids:
+    except Exception as e:
 
-                    models_data.append({
-                        "id": model_str,
-                        "object": "model",
-                        "created": int(time.time()),
-                        "owned_by": "g4f",
-                        "providers_available": 1,
-                        "permission": [],
-                        "root": model_str,
-                        "parent": None
-                    })
+        logger.error(f"Models error: {e}")
 
-                    existing_ids.add(model_str)
+    # fallback
+    if not models_data:
 
-    except Exception as e:
+        for model in fallback_models:
 
-        logger.warning(
-            f"Could not fetch g4f models: {e}"
-        )
+            models_data.append({
+                "id": model,
+                "object": "model",
+                "created": int(time.time()),
+                "owned_by": "g4f"
+            })
 
     return {
         "object": "list",
-        "data": models_data,
-        "total": len(models_data)
+        "data": models_data
     }
 
-
 # =====================================================
 # CHAT COMPLETIONS
 # =====================================================
@@ -671,7 +180,7 @@ async def chat_completions(
     ]
 
     logger.info(
-        f"Request | model={body.model} | stream={body.stream}"
+        f"Request model={body.model} stream={body.stream}"
     )
 
     # =================================================
@@ -684,7 +193,9 @@ async def chat_completions(
 
             try:
 
-                response, actual_model = await smart_completion(
+                client = Client()
+
+                response = client.chat.completions.create(
                     model=body.model,
                     messages=messages,
                     stream=True
@@ -700,7 +211,6 @@ async def chat_completions(
 
                         if (
                             chunk.choices
-                            and len(chunk.choices) > 0
                             and chunk.choices[0].delta
                             and chunk.choices[0].delta.content
                         ):
@@ -712,12 +222,11 @@ async def chat_completions(
                                 "id": chunk_id,
                                 "object": "chat.completion.chunk",
                                 "created": int(time.time()),
-                                "model": actual_model,
+                                "model": body.model,
                                 "choices": [
                                     {
                                         "index": 0,
                                         "delta": {
-                                            "role": "assistant",
                                             "content": content
                                         },
                                         "finish_reason": None
@@ -725,26 +234,21 @@ async def chat_completions(
                                 ]
                             }
 
-                            yield (
-                                f"data: "
-                                f"{json.dumps(payload, ensure_ascii=False)}\n\n"
-                            )
+                            yield f"data: {json.dumps(payload)}\n\n"
 
                             await asyncio.sleep(0)
 
                     except Exception as chunk_error:
 
                         logger.error(
-                            f"Chunk processing error: {chunk_error}"
+                            f"Chunk error: {chunk_error}"
                         )
 
-                        continue
-
                 final_payload = {
                     "id": chunk_id,
                     "object": "chat.completion.chunk",
                     "created": int(time.time()),
-                    "model": actual_model,
+                    "model": body.model,
                     "choices": [
                         {
                             "index": 0,
@@ -754,16 +258,13 @@ async def chat_completions(
                     ]
                 }
 
-                yield (
-                    f"data: "
-                    f"{json.dumps(final_payload)}\n\n"
-                )
+                yield f"data: {json.dumps(final_payload)}\n\n"
 
                 yield "data: [DONE]\n\n"
 
             except Exception as e:
 
-                logger.error(f"Stream generation error: {e}")
+                logger.error(f"Streaming error: {e}")
 
                 error_payload = {
                     "error": {
@@ -772,10 +273,7 @@ async def chat_completions(
                     }
                 }
 
-                yield (
-                    f"data: "
-                    f"{json.dumps(error_payload)}\n\n"
-                )
+                yield f"data: {json.dumps(error_payload)}\n\n"
 
         return StreamingResponse(
             generate_stream(),
@@ -783,8 +281,7 @@ async def chat_completions(
             headers={
                 "Cache-Control": "no-cache",
                 "Connection": "keep-alive",
-                "X-Accel-Buffering": "no",
-                "Transfer-Encoding": "chunked"
+                "X-Accel-Buffering": "no"
             }
         )
 
@@ -794,46 +291,26 @@ async def chat_completions(
 
     try:
 
-        proxy = get_proxy()
+        client = Client()
 
-        response, actual_model = await smart_completion(
+        response = await asyncio.to_thread(
+            client.chat.completions.create,
             model=body.model,
-            messages=messages,
-            stream=False,
-            max_retries=3,
-            proxy=proxy
+            messages=messages
         )
 
         assistant_message = ""
 
         try:
-
-            assistant_message = (
-                response.choices[0].message.content or ""
-            )
-
-        except AttributeError:
-
-            try:
-                assistant_message = str(response)
-
-            except Exception:
-                assistant_message = "Error extracting response"
-
-        prompt_tokens = sum(
-            len(m["content"].split())
-            for m in messages
-        )
-
-        completion_tokens = len(
-            assistant_message.split()
-        )
+            assistant_message = response.choices[0].message.content
+        except:
+            assistant_message = str(response)
 
         return JSONResponse({
             "id": f"chatcmpl-{uuid.uuid4().hex}",
             "object": "chat.completion",
             "created": int(time.time()),
-            "model": actual_model,
+            "model": body.model,
             "choices": [
                 {
                     "index": 0,
@@ -845,31 +322,21 @@ async def chat_completions(
                 }
             ],
             "usage": {
-                "prompt_tokens": prompt_tokens,
-                "completion_tokens": completion_tokens,
-                "total_tokens": (
-                    prompt_tokens + completion_tokens
-                )
+                "prompt_tokens": 0,
+                "completion_tokens": 0,
+                "total_tokens": 0
             }
         })
 
-    except HTTPException:
-        raise
-
     except Exception as e:
 
-        logger.error(f"Chat completion error: {e}")
+        logger.error(f"Chat error: {e}")
 
         raise HTTPException(
             status_code=500,
-            detail={
-                "error": str(e),
-                "model": body.model,
-                "message": "Internal server error"
-            }
+            detail=str(e)
         )
 
-
 # =====================================================
 # RUN
 # =====================================================
@@ -878,21 +345,8 @@ if __name__ == "__main__":
 
     import uvicorn
 
-    logger.info(
-        "Starting Universal AI Gateway v5.0.0"
-    )
-
-    logger.info(
-        f"Proxy enabled: {bool(PROXY_LIST or SINGLE_PROXY)}"
-    )
-
-    logger.info(
-        f"Models configured: {len(MODEL_PROVIDER_MAP)}"
-    )
-
     uvicorn.run(
         app,
         host="0.0.0.0",
-        port=7860,
-        log_level="info"
+        port=7860
     )