Upload app.py

app.py

@@ -1,162 +1,105 @@
-from fastapi import FastAPI, HTTPException, Depends, Header
+from fastapi import FastAPI, HTTPException, Depends, Header, Request
 from fastapi.responses import StreamingResponse
 from pydantic import BaseModel
-from typing import List, Optional, Literal
-import json
-import g4f
-from g4f.Provider import OpenaiAccount, RetryProvider
+from typing import List
+from g4f import ChatCompletion
 
 app = FastAPI()
 
-# Organized model list (updated with all G4F available models)
-MODELS = {
-    # OpenAI
-    "openai": [
-        "gpt-4o", "gpt-4o-mini", "gpt-4", "gpt-4-turbo", 
-        "gpt-3.5-turbo", "gpt-3.5-turbo-16k"
-    ],
-    
-    # Anthropic
-    "anthropic": [
-        "claude-3-opus", "claude-3-sonnet", "claude-3-haiku",
-        "claude-3.5", "claude-3.7-sonnet", "claude-2.1"
-    ],
-    
-    # Google
-    "google": [
-        "gemini-pro", "gemini-1.5-pro", "gemini-1.5-flash",
-        "gemini-2.5-pro-exp-03-25"
-    ],
-    
-    # Meta
-    "meta": [
-        "llama-3-70b", "llama-3-8b", "llama-3.1-405b",
-        "llama-2-70b", "llama-2-13b", "llama-2-7b"
-    ],
-    
-    # XAI (Grok)
-    "xai": [
-        "grok-1", "grok-1.5", "grok-2", "grok-3"
-    ],
-    
-    # Other
-    "other": [
-        "o1", "o3-mini", "mistral-7b", "mixtral-8x7b",
-        "command-r-plus", "deepseek-chat", "code-llama-70b"
-    ],
-    
-    # Image Models
-    "image": [
-        "dall-e-3", "stable-diffusion-xl",
-        "flux", "flux-pro", "playground-v2.5"
-    ]
-}
-
-# Flattened list for API endpoint
-ALL_MODELS = [
-    *MODELS["openai"],
-    *MODELS["anthropic"],
-    *MODELS["google"],
-    *MODELS["meta"],
-    *MODELS["xai"],
-    *MODELS["other"]
+# List of available models
+models = [
+    "gpt-4o", "gpt-4o-mini", "gpt-4",
+    "gpt-4-turbo", "gpt-3.5-turbo",
+    "claude-3.7-sonnet", "o3-mini", "o1", "grok-3", "gemini-2.5-pro-exp-03-25", "claude-3.5", 
+    "llama-3.1-405b"
 ]
 
-# Pydantic Models
+# Request model
 class Message(BaseModel):
-    role: Literal["system", "user", "assistant"]
+    role: str
     content: str
 
 class ChatRequest(BaseModel):
     model: str
     messages: List[Message]
-    temperature: Optional[float] = 0.7
-    max_tokens: Optional[int] = None
-    top_p: Optional[float] = 0.9
-    stream: Optional[bool] = True
+    streaming: bool = True
+
+class ChatResponse(BaseModel):
+    role: str
+    content: str
 
-class ModelListResponse(BaseModel):
-    openai: List[str]
-    anthropic: List[str]
-    google: List[str]
-    meta: List[str]
-    xai: List[str]
-    other: List[str]
-    image: List[str]
+# Dependency to check API key
+async def verify_api_key(x_api_key: str = Header(...)):
+    if x_api_key != "fb207532285886a5568298b4b4e61124":
+        raise HTTPException(status_code=403, detail="Invalid API key")
 
-# API Endpoints
-@app.get("/v1/models", response_model=ModelListResponse)
+@app.get("/v1/models", tags=["Models"])
 async def get_models():
-    """Get all available models categorized by provider"""
-    return ModelListResponse(**MODELS)
+    """Endpoint to get the list of available models."""
+    return {"models": models}
+
+@app.post("/v1/chat/completions", tags=["Chat Completion"])
+async def chat_completion(
+    chat_request: ChatRequest,
+    api_key: str = Depends(verify_api_key)
+):
+    """
+    Handle chat completion requests with optional streaming.
+    Removed rate limiting for unrestricted access.
+    """
+    # Validate model
+    if chat_request.model not in models:
+        raise HTTPException(status_code=400, detail="Invalid model selected.")
+
+    # Check if messages are provided
+    if not chat_request.messages:
+        raise HTTPException(status_code=400, detail="Messages cannot be empty.")
+
+    # Convert messages to the format expected by ChatCompletion
+    formatted_messages = [{"role": msg.role, "content": msg.content} for msg in chat_request.messages]
 
-@app.post("/v1/chat/completions")
-async def chat_completion(request: ChatRequest):
-    """Handle chat completion requests"""
-    if request.model not in ALL_MODELS:
-        raise HTTPException(
-            status_code=400,
-            detail=f"Invalid model. Available: {ALL_MODELS}"
-        )
-    
-    messages = [{"role": msg.role, "content": msg.content} for msg in request.messages]
-    
     try:
-        if request.stream:
-            async def stream_generator():
-                response = await g4f.ChatCompletion.create_async(
-                    model=request.model,
-                    messages=messages,
-                    temperature=request.temperature,
-                    top_p=request.top_p,
-                    max_tokens=request.max_tokens,
-                    provider=RetryProvider([g4f.Provider.BackendApi])
+        if chat_request.streaming:
+            # Stream the response
+            def event_stream():
+                response = ChatCompletion.create(
+                    model=chat_request.model,
+                    messages=formatted_messages,
+                    stream=True
                 )
                 
-                async for chunk in response:
-                    yield f"data: {json.dumps({'content': str(chunk)})}\n\n"
-                yield "data: [DONE]\n\n"
-            
-            return StreamingResponse(stream_generator(), media_type="text/event-stream")
-        else:
-            response = await g4f.ChatCompletion.create_async(
-                model=request.model,
-                messages=messages,
-                temperature=request.temperature,
-                top_p=request.top_p,
-                provider=RetryProvider([g4f.Provider.BackendApi])
-            )
-            return {"content": str(response)}
-    
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
+                for chunk in response:
+                    if isinstance(chunk, dict) and 'choices' in chunk:
+                        for choice in chunk['choices']:
+                            if 'delta' in choice and 'content' in choice['delta']:
+                                yield f"data: {json.dumps({'content': choice['delta']['content']})}\n\n"
+                            elif 'message' in choice:
+                                yield f"data: {json.dumps({'content': choice['message']['content']})}\n\n"
+                    else:
+                        yield f"data: {json.dumps({'content': str(chunk)})}\n\n"
 
-# Image Generation Endpoint
-@app.post("/v1/images/generations")
-async def generate_image(prompt: str, model: str = "dall-e-3"):
-    if model not in MODELS["image"]:
-        raise HTTPException(
-            status_code=400,
-            detail=f"Invalid image model. Available: {MODELS['image']}"
-        )
-    
-    try:
-        if model in ["flux", "flux-pro"]:
-            image_data = g4f.ImageGeneration.create(
-                prompt=prompt,
-                model=model,
-                provider=g4f.Provider.BackendApi
-            )
-            return {"url": f"data:image/png;base64,{image_data.decode('utf-8')}"}
+            return StreamingResponse(event_stream(), media_type="text/event-stream")
         else:
-            # Implementation for other image providers
-            raise HTTPException(
-                status_code=501,
-                detail=f"{model} implementation pending"
+            # Non-streaming response
+            response = ChatCompletion.create(
+                model=chat_request.model,
+                messages=formatted_messages,
+                stream=False
             )
+
+            if isinstance(response, str):
+                return ChatResponse(role="assistant", content=response)
+            elif isinstance(response, dict) and 'choices' in response:
+                return ChatResponse(
+                    role="assistant",
+                    content=response['choices'][0]['message']['content']
+                )
+            else:
+                raise HTTPException(status_code=500, detail="Unexpected response structure.")
+
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
 if __name__ == "__main__":
     import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=8000)
+    uvicorn.run(app, host="0.0.0.0", port=7860)