Update main.py

main.py

@@ -2,6 +2,7 @@ import os
 import json
 import g4f
 import logging
+import time
 from fastapi import FastAPI, HTTPException, Header, Request
 from fastapi.responses import StreamingResponse
 from fastapi.middleware.cors import CORSMiddleware
@@ -12,11 +13,7 @@ from typing import List, Optional
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# ---------------- App ----------------
-app = FastAPI(
-    title="G4F OpenAI Compatible API",
-    version="1.0"
-)
+app = FastAPI(title="G4F Dynamic API")
 
 app.add_middleware(
     CORSMiddleware,
@@ -28,200 +25,78 @@ app.add_middleware(
 
 API_KEY = os.getenv("API_KEY", "your_fallback_secret")
 
-# ---------------- Models ----------------
 class ChatMessage(BaseModel):
     role: str
     content: str
 
 class ChatRequest(BaseModel):
-    model: str = "gpt-4o-mini"
+    model: str # أزلنا القيمة الافتراضية لنجعل المستخدم يختار أو نعتمد على g4f.models.default
     messages: List[ChatMessage]
     stream: bool = False
     provider: Optional[str] = None
-    max_tokens: Optional[int] = 2048
-    temperature: Optional[float] = 0.7
-
 
-# ---------------- Auth ----------------
 def verify_key(auth: str):
+    if not auth or not auth.startswith("Bearer "):
+        raise HTTPException(status_code=401, detail="Invalid or missing Token")
+    token = auth.split(" ")[1]
+    if token != API_KEY:
+        raise HTTPException(status_code=401, detail="Unauthorized")
 
-    if not auth:
-        raise HTTPException(
-            status_code=401,
-            detail="Missing Authorization header"
-        )
-
-    parts = auth.split()
-
-    if len(parts) != 2:
-        raise HTTPException(
-            status_code=401,
-            detail="Malformed Authorization"
-        )
-
-    if parts[0] != "Bearer":
-        raise HTTPException(
-            status_code=401,
-            detail="Malformed Authorization"
-        )
-
-    if parts[1] != API_KEY:
-        raise HTTPException(
-            status_code=401,
-            detail="Invalid API Key"
-        )
-
-
-# ---------------- Health ----------------
-@app.get("/")
-async def health():
-    return {
-        "status": "online"
-    }
-
-
-# ---------------- OpenAI models endpoint ----------------
 @app.get("/v1/models")
-async def models(
-    authorization: str = Header(None)
-):
-
+async def list_models(authorization: str = Header(None)):
     verify_key(authorization)
-
+    # استخراج كافة النماذج المتوفرة في الإصدار الحالي للمكتبة
+    model_list = sorted(g4f.models._all) 
     return {
         "object": "list",
-        "data": [
-            {
-                "id": "gpt-4o-mini",
-                "object": "model"
-            },
-            {
-                "id": "gpt-3.5-turbo",
-                "object": "model"
-            },
-            {
-                "id": "gpt-4",
-                "object": "model"
-            }
-        ]
+        "data": [{"id": m, "object": "model", "owned_by": "g4f"} for m in model_list]
     }
 
-
-# ---------------- Chat ----------------
 @app.post("/v1/chat/completions")
-async def chat(
-    body: ChatRequest,
-    authorization: str = Header(None)
-):
-
+async def chat(body: ChatRequest, authorization: str = Header(None)):
     verify_key(authorization)
-
+    
     try:
+        messages = [{"role": m.role, "content": m.content} for m in body.messages]
+        provider = getattr(g4f.Provider, body.provider, None) if body.provider else None
 
-        provider = None
-
-        if body.provider:
-
-            provider = getattr(
-                g4f.Provider,
-                body.provider,
-                None
-            )
-
-            if provider is None:
-                raise HTTPException(
-                    status_code=400,
-                    detail="Invalid provider"
-                )
-
-
-        messages = [
-            {
-                "role":m.role,
-                "content":m.content
-            }
-            for m in body.messages
-        ]
-
-
-        # ---------- Streaming ----------
         if body.stream:
-
             def generate():
-
-                try:
-
-                    response = g4f.ChatCompletion.create(
-                        model=body.model,
-                        messages=messages,
-                        provider=provider,
-                        stream=True
-                    )
-
-                    for chunk in response:
-
-                        if not chunk:
-                            continue
-
+                response = g4f.ChatCompletion.create(
+                    model=body.model,
+                    messages=messages,
+                    provider=provider,
+                    stream=True
+                )
+                for chunk in response:
+                    if chunk:
                         payload = {
-                            "choices":[
-                                {
-                                    "delta":{
-                                        "content":chunk
-                                    },
-                                    "index":0
-                                }
-                            ]
+                            "id": "chatcmpl-" + str(int(time.time())),
+                            "object": "chat.completion.chunk",
+                            "created": int(time.time()),
+                            "model": body.model,
+                            "choices": [{"delta": {"content": chunk}, "index": 0, "finish_reason": None}]
                         }
-
                         yield f"data: {json.dumps(payload)}\n\n"
+                yield "data: [DONE]\n\n"
 
-                    yield "data: [DONE]\n\n"
-
-                except Exception as e:
-                    logger.exception(e)
-
-                    err={
-                        "error":"stream failed"
-                    }
-
-                    yield f"data: {json.dumps(err)}\n\n"
-
-
-            return StreamingResponse(
-                generate(),
-                media_type="text/event-stream"
-            )
+            return StreamingResponse(generate(), media_type="text/event-stream")
 
-
-        # ---------- Normal ----------
+        # العادي
         response = await g4f.ChatCompletion.create_async(
             model=body.model,
             messages=messages,
             provider=provider
         )
-
+        
         return {
-            "id":"chatcmpl-g4f",
-            "object":"chat.completion",
-            "choices":[
-                {
-                    "index":0,
-                    "message":{
-                        "role":"assistant",
-                        "content":response
-                    },
-                    "finish_reason":"stop"
-                }
-            ]
+            "id": "chatcmpl-g4f",
+            "object": "chat.completion",
+            "created": int(time.time()),
+            "model": body.model,
+            "choices": [{"index": 0, "message": {"role": "assistant", "content": response}, "finish_reason": "stop"}]
         }
 
-
     except Exception as e:
-
-        logger.exception(e)
-
-        raise HTTPException(
-            status_code=503,
-            detail="Provider unavailable"
-        )
+        logger.error(f"Error: {e}")
+        raise HTTPException(status_code=500, detail=str(e))