Update main.py

main.py

@@ -1,102 +1,224 @@
-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
-from pydantic import BaseModel
-from typing import List, Optional
-
-# ---------------- Logging ----------------
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-app = FastAPI(title="G4F Dynamic API")
-
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=False,
-    allow_methods=["*"],
-    allow_headers=["*"]
-)
+import os import json import time import logging import g4f from fastapi import FastAPI, HTTPException, Header from fastapi.responses import StreamingResponse from fastapi.middleware.cors import CORSMiddleware from pydantic import BaseModel from typing import List, Optional
+
+---------------- Logging ----------------
+
+logging.basicConfig(level=logging.INFO) logger = logging.getLogger(name)
+
+---------------- App ----------------
+
+app = FastAPI( title="G4F OpenAI Compatible API", version="1.0" )
+
+app.add_middleware( CORSMiddleware, allow_origins=[""], allow_credentials=False, allow_methods=[""], allow_headers=["*"] )
 
 API_KEY = os.getenv("API_KEY", "your_fallback_secret")
 
-class ChatMessage(BaseModel):
-    role: str
-    content: str
+---------------- Models ----------------
+
+class ChatMessage(BaseModel): role: str content: str
 
-class ChatRequest(BaseModel):
-    model: str # أزلنا القيمة الافتراضية لنجعل المستخدم يختار أو نعتمد على g4f.models.default
-    messages: List[ChatMessage]
-    stream: bool = False
-    provider: Optional[str] = None
+class ChatRequest(BaseModel): model: str = "gpt-4o-mini" 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")
-
-@app.get("/v1/models")
-async def list_models(authorization: str = Header(None)):
-    verify_key(authorization)
-    # استخراج كافة النماذج المتوفرة في الإصدار الحالي للمكتبة
-    model_list = sorted(g4f.models._all) 
+
+if not auth:
+    raise HTTPException(
+        status_code=401,
+        detail="Missing Authorization"
+    )
+
+parts = auth.split()
+
+if len(parts) != 2 or 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" }
+
+---------------- Dynamic Models ----------------
+
+@app.get("/v1/models") async def models( authorization: str = Header(None) ):
+
+verify_key(authorization)
+
+try:
+
+    model_data=[]
+
+    # الطريقة الأكثر استقرارًا مع g4f
+    if hasattr(g4f,"ModelUtils"):
+
+        for model_name in g4f.ModelUtils.convert.keys():
+
+            model_data.append({
+                "id":str(model_name),
+                "object":"model"
+            })
+
+    # fallback
+    if not model_data:
+
+        for name in dir(g4f.models):
+
+            if name.startswith("_"):
+                continue
+
+            value=getattr(
+                g4f.models,
+                name,
+                None
+            )
+
+            if isinstance(value,str):
+
+                model_data.append({
+                    "id":value,
+                    "object":"model"
+                })
+
+    unique={}
+
+    for m in model_data:
+        unique[m["id"]]=m
+
     return {
-        "object": "list",
-        "data": [{"id": m, "object": "model", "owned_by": "g4f"} for m in model_list]
+        "object":"list",
+        "data":sorted(
+            unique.values(),
+            key=lambda x:x["id"]
+        )
     }
 
-@app.post("/v1/chat/completions")
-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
-
-        if body.stream:
-            def generate():
-                response = g4f.ChatCompletion.create(
+except Exception as e:
+
+    logger.exception(e)
+
+    return {
+        "object":"list",
+        "data":[
+            {
+                "id":"gpt-4o-mini",
+                "object":"model"
+            }
+        ]
+    }
+
+---------------- Chat ----------------
+
+@app.post("/v1/chat/completions") async def chat( body: ChatRequest, authorization: str = Header(None) ):
+
+verify_key(authorization)
+
+try:
+
+    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 chunk:
-                        payload = {
-                            "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"
+
+                    payload={
+                        "id":f"chatcmpl-{int(time.time())}",
+                        "object":"chat.completion.chunk",
+                        "created":int(time.time()),
+                        "model":body.model,
+                        "choices":[
+                            {
+                                "delta":{
+                                    "content":str(chunk)
+                                },
+                                "index":0,
+                                "finish_reason":None
+                            }
+                        ]
+                    }
+
+                    yield f"data: {json.dumps(payload)}\n\n"
+
                 yield "data: [DONE]\n\n"
 
-            return StreamingResponse(generate(), media_type="text/event-stream")
+            except Exception as e:
+                logger.exception(e)
 
-        # العادي
-        response = await g4f.ChatCompletion.create_async(
-            model=body.model,
-            messages=messages,
-            provider=provider
+        return StreamingResponse(
+            generate(),
+            media_type="text/event-stream"
         )
-        
-        return {
-            "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.error(f"Error: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
+    # -------- Non-stream --------
+    response=await g4f.ChatCompletion.create_async(
+        model=body.model,
+        messages=messages,
+        provider=provider
+    )
+
+    return {
+        "id":f"chatcmpl-{int(time.time())}",
+        "object":"chat.completion",
+        "created":int(time.time()),
+        "model":body.model,
+        "choices":[
+            {
+                "index":0,
+                "message":{
+                    "role":"assistant",
+                    "content":str(response)
+                },
+                "finish_reason":"stop"
+            }
+        ]
+    }
+
+except Exception as e:
+
+    logger.exception(e)
+
+    raise HTTPException(
+        status_code=503,
+        detail=f"Provider error: {str(e)}"
+    )