Update main.py

main.py

@@ -1,224 +1,312 @@
-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
+import os
+import json
+import time
+import logging
+import g4f
 
----------------- Logging ----------------
+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.basicConfig(level=logging.INFO) logger = logging.getLogger(name)
 
----------------- App ----------------
+# ================= Logging =================
 
-app = FastAPI( title="G4F OpenAI Compatible API", version="1.0" )
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
-app.add_middleware( CORSMiddleware, allow_origins=[""], allow_credentials=False, allow_methods=[""], allow_headers=["*"] )
 
-API_KEY = os.getenv("API_KEY", "your_fallback_secret")
+# ================= App =================
 
----------------- Models ----------------
+app = FastAPI(
+    title="G4F OpenAI API",
+    version="1.0"
+)
 
-class ChatMessage(BaseModel): role: str content: str
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=False,
+    allow_methods=["*"],
+    allow_headers=["*"]
+)
 
-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 ----------------
+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"
+    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:
-    raise HTTPException(
-        status_code=401,
-        detail="Missing Authorization"
-    )
+    if not auth:
+        raise HTTPException(
+            status_code=401,
+            detail="Missing Authorization"
+        )
 
-parts = auth.split()
+    parts = auth.split()
 
-if len(parts) != 2 or parts[0] != "Bearer":
-    raise HTTPException(
-        status_code=401,
-        detail="Malformed Authorization"
-    )
+    if len(parts) != 2:
+        raise HTTPException(
+            status_code=401,
+            detail="Malformed Authorization"
+        )
 
-if parts[1] != API_KEY:
-    raise HTTPException(
-        status_code=401,
-        detail="Invalid API Key"
-    )
+    if parts[0] != "Bearer":
+        raise HTTPException(
+            status_code=401,
+            detail="Invalid Bearer"
+        )
 
----------------- Health ----------------
+    if parts[1] != API_KEY:
+        raise HTTPException(
+            status_code=401,
+            detail="Invalid API Key"
+        )
 
-@app.get("/") async def health(): return { "status": "online" }
 
----------------- Dynamic Models ----------------
+# ================= Health =================
 
-@app.get("/v1/models") async def models( authorization: str = Header(None) ):
+@app.get("/")
+async def root():
 
-verify_key(authorization)
+    return {
+        "status": "online"
+    }
 
-try:
 
-    model_data=[]
+# ================= Models Endpoint =================
 
-    # الطريقة الأكثر استقرارًا مع g4f
-    if hasattr(g4f,"ModelUtils"):
+@app.get("/v1/models")
+async def models(
+    authorization: str = Header(None)
+):
 
-        for model_name in g4f.ModelUtils.convert.keys():
+    verify_key(authorization)
 
-            model_data.append({
-                "id":str(model_name),
-                "object":"model"
-            })
+    try:
 
-    # fallback
-    if not model_data:
+        found = []
 
+        # استخراج أسماء النماذج تلقائياً
         for name in dir(g4f.models):
 
             if name.startswith("_"):
                 continue
 
-            value=getattr(
+            obj = getattr(
                 g4f.models,
-                name,
-                None
+                name
             )
 
-            if isinstance(value,str):
+            if isinstance(name, str):
+                found.append(name)
+
+        found = sorted(list(set(found)))
+
+        if not found:
+            found = [
+                "gpt-4o-mini",
+                "gpt-4",
+                "gpt-3.5-turbo"
+            ]
+
+        return {
+            "object": "list",
+            "data": [
+                {
+                    "id": model,
+                    "object": "model",
+                    "owned_by": "g4f"
+                }
+                for model in found
+            ]
+        }
 
-                model_data.append({
-                    "id":value,
-                    "object":"model"
-                })
+    except Exception as e:
 
-    unique={}
+        logger.error(e)
 
-    for m in model_data:
-        unique[m["id"]]=m
+        return {
+            "object": "list",
+            "data": [
+                {
+                    "id": "gpt-4o-mini",
+                    "object": "model"
+                }
+            ]
+        }
 
-    return {
-        "object":"list",
-        "data":sorted(
-            unique.values(),
-            key=lambda x:x["id"]
-        )
-    }
 
-except Exception as e:
+# ================= Chat =================
 
-    logger.exception(e)
+@app.post("/v1/chat/completions")
+async def chat(
+    body: ChatRequest,
+    authorization: str = Header(None)
+):
 
-    return {
-        "object":"list",
-        "data":[
+    verify_key(authorization)
+
+    try:
+
+        provider = None
+
+        if body.provider:
+
+            provider = getattr(
+                g4f.Provider,
+                body.provider,
+                None
+            )
+
+        messages = [
             {
-                "id":"gpt-4o-mini",
-                "object":"model"
+                "role": m.role,
+                "content": m.content
             }
+            for m in body.messages
         ]
-    }
 
----------------- Chat ----------------
 
-@app.post("/v1/chat/completions") async def chat( body: ChatRequest, authorization: str = Header(None) ):
+        # ================= STREAM =================
 
-verify_key(authorization)
+        if body.stream:
 
-try:
+            def generate():
 
-    provider=None
+                try:
 
-    if body.provider:
+                    response = g4f.ChatCompletion.create(
+                        model=body.model,
+                        messages=messages,
+                        provider=provider,
+                        stream=True
+                    )
 
-        provider=getattr(
-            g4f.Provider,
-            body.provider,
-            None
-        )
+                    for chunk in response:
 
-        if provider is None:
-            raise HTTPException(
-                status_code=400,
-                detail="Invalid provider"
-            )
+                        if not chunk:
+                            continue
+
+                        payload = {
+
+                            "id":
+                            "chatcmpl-"+str(
+                                int(time.time())
+                            ),
+
+                            "object":
+                            "chat.completion.chunk",
+
+                            "created":
+                            int(time.time()),
+
+                            "model":
+                            body.model,
+
+                            "choices":[
+                                {
+                                    "delta":{
+                                        "content":
+                                        str(chunk)
+                                    },
+                                    "index":0
+                                }
+                            ]
+                        }
+
+                        yield (
+                            "data: "
+                            + json.dumps(payload)
+                            + "\n\n"
+                        )
+
+                    yield "data: [DONE]\n\n"
+
+                except Exception as e:
+
+                    logger.error(e)
+
+                    error_payload={
+
+                        "error":
+                        str(e)
 
-    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:
-
-                    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: "
+                        + json.dumps(error_payload)
+                        + "\n\n"
+                    )
+
+            return StreamingResponse(
+                generate(),
+                media_type="text/event-stream"
+            )
 
-                yield "data: [DONE]\n\n"
 
-            except Exception as e:
-                logger.exception(e)
+        # ================= NORMAL =================
 
-        return StreamingResponse(
-            generate(),
-            media_type="text/event-stream"
+        response = await g4f.ChatCompletion.create_async(
+            model=body.model,
+            messages=messages,
+            provider=provider
         )
 
-    # -------- Non-stream --------
-    response=await g4f.ChatCompletion.create_async(
-        model=body.model,
-        messages=messages,
-        provider=provider
-    )
+        return {
 
-    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"
-            }
-        ]
-    }
+            "id":
+            "chatcmpl-g4f",
+
+            "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:
+    except Exception as e:
 
-    logger.exception(e)
+        logger.exception(e)
 
-    raise HTTPException(
-        status_code=503,
-        detail=f"Provider error: {str(e)}"
-    )
+        raise HTTPException(
+            status_code=503,
+            detail=str(e)
+        )