Update main.py

main.py

@@ -1,111 +1,47 @@
 import os
 from dotenv import load_dotenv
-from fastapi import FastAPI, HTTPException, Request
-from fastapi.responses import StreamingResponse, HTMLResponse, JSONResponse, FileResponse  
+from fastapi import FastAPI, HTTPException, Request, Depends, Security
+from fastapi.responses import StreamingResponse, HTMLResponse, JSONResponse, FileResponse
+from fastapi.security import APIKeyHeader
 from pydantic import BaseModel
 import httpx
-import hashlib
 from functools import lru_cache
-from pathlib import Path  # Import Path from pathlib
-import requests
-import re
-import cloudscraper
+from pathlib import Path
 import json
-from typing import Optional
 import datetime
 import time
-from usage_tracker import UsageTracker
-from starlette.middleware.base import BaseHTTPMiddleware
-from collections import defaultdict
-from fastapi import Security #new
-from fastapi import Depends
-from fastapi.security import APIKeyHeader
-from starlette.exceptions import HTTPException
+from typing import Optional, Dict, List, Any, Generator
+import asyncio
 from starlette.status import HTTP_403_FORBIDDEN
+import cloudscraper
 
-# API key header scheme
-api_key_header = APIKeyHeader(name="Authorization", auto_error=False)
+# Load environment variables once at startup
+load_dotenv()
 
-# Function to validate API key
-async def verify_api_key(api_key: str = Security(api_key_header)) -> bool:
-    if not api_key:
-        raise HTTPException(
-            status_code=HTTP_403_FORBIDDEN,
-            detail="No API key provided"
-        )
-        
-    # Clean the API key by removing 'Bearer ' if present
-    if api_key.startswith('Bearer '):
-        api_key = api_key[7:]  # Remove 'Bearer ' prefix
-        
-    # Get API keys from environment
-    api_keys_str = os.getenv('API_KEYS')
-    if not api_keys_str:
-        raise HTTPException(
-            status_code=HTTP_403_FORBIDDEN,
-            detail="API keys not configured on server"
-        )
-        
-    valid_api_keys = api_keys_str.split(',')
-    
-    # Check if the provided key is valid
-    if api_key not in valid_api_keys:
-        raise HTTPException(
-            status_code=HTTP_403_FORBIDDEN,
-            detail="Invalid API key"
-        )
-        
-    return True
-class RateLimitMiddleware(BaseHTTPMiddleware):
-    def __init__(self, app, requests_per_second: int = 2):
-        super().__init__(app)
-        self.requests_per_second = requests_per_second
-        self.last_request_time = defaultdict(float)
-        self.tokens = defaultdict(lambda: requests_per_second)
-        self.last_update = defaultdict(float)
-        
-    async def dispatch(self, request: Request, call_next):
-        client_ip = request.client.host
-        current_time = time.time()
-        
-        # Update tokens
-        time_passed = current_time - self.last_update[client_ip]
-        self.last_update[client_ip] = current_time
-        self.tokens[client_ip] = min(
-            self.requests_per_second,
-            self.tokens[client_ip] + time_passed * self.requests_per_second
-        )
-        
-        # Check if request can be processed
-        if self.tokens[client_ip] < 1:
-            return JSONResponse(
-                status_code=429,
-                content={
-                    "detail": "Too many requests. Please try again later.",
-                    "retry_after": round((1 - self.tokens[client_ip]) / self.requests_per_second)
-                }
-            )
-            
-        # Consume a token
-        self.tokens[client_ip] -= 1
-        
-        # Process the request
-        response = await call_next(request)
-        return response
+# API key security scheme
+api_key_header = APIKeyHeader(name="Authorization", auto_error=False)
 
+# Initialize usage tracker
+from usage_tracker import UsageTracker
 usage_tracker = UsageTracker()
-load_dotenv() #idk why this shi
 
 app = FastAPI()
-app.add_middleware(RateLimitMiddleware, requests_per_second=2)
-
-# Get API keys and secret endpoint from environment variables
-# valid_api_keys = api_keys_str.split(',') if api_keys_str else []
-secret_api_endpoint = os.getenv('SECRET_API_ENDPOINT')
-secret_api_endpoint_2 = os.getenv('SECRET_API_ENDPOINT_2')
-secret_api_endpoint_3 = os.getenv('SECRET_API_ENDPOINT_3')  # New endpoint for searchgpt
-mistral_api = "https://api.mistral.ai"
-mistral_key = os.getenv('MISTRAL_KEY')
+
+# Environment variables (cached)
+@lru_cache(maxsize=1)
+def get_env_vars():
+    return {
+        'api_keys': os.getenv('API_KEYS', '').split(','),
+        'secret_api_endpoint': os.getenv('SECRET_API_ENDPOINT'),
+        'secret_api_endpoint_2': os.getenv('SECRET_API_ENDPOINT_2'),
+        'secret_api_endpoint_3': os.getenv('SECRET_API_ENDPOINT_3'),
+        'mistral_api': "https://api.mistral.ai",
+        'mistral_key': os.getenv('MISTRAL_KEY'),
+        'image_endpoint': os.getenv("IMAGE_ENDPOINT"),
+        'endpoint_origin': os.getenv('ENDPOINT_ORIGIN')
+    }
+
+# Configuration for models
 mistral_models = [
     "mistral-large-latest",
     "pixtral-large-latest",
@@ -118,14 +54,6 @@ mistral_models = [
     "codestral-latest"
 ]
 
-image_endpoint = os.getenv("IMAGE_ENDPOINT")
-ENDPOINT_ORIGIN = os.getenv('ENDPOINT_ORIGIN') 
-
-# Validate if the main secret API endpoints are set
-if not secret_api_endpoint or not secret_api_endpoint_2 or not secret_api_endpoint_3:
-    raise HTTPException(status_code=500, detail="API endpoint(s) are not configured in environment variables.")
-
-# Define models that should use the secondary endpoint
 alternate_models = {
     "gpt-4o-mini",
     "deepseek-v3",
@@ -140,19 +68,64 @@ alternate_models = {
     "hermes-3-llama-3.2-3b"
 }
 
-available_model_ids = []
+# Request payload model
 class Payload(BaseModel):
     model: str
     messages: list
     stream: bool = False
-    
-@app.get("/favicon.ico")
-async def favicon():
-    # The favicon.ico file is in the same directory as the app
-    favicon_path = Path(__file__).parent / "favicon.ico"
-    return FileResponse(favicon_path, media_type="image/x-icon")
-    
-def generate_search(query: str, systemprompt: Optional[str] = None, stream: bool = True) -> str:
+
+# Server status global variable
+server_status = True
+available_model_ids: List[str] = []
+
+# Create a reusable httpx client
+@lru_cache(maxsize=1)
+def get_async_client():
+    return httpx.AsyncClient(timeout=60.0)
+
+# API key validation
+async def verify_api_key(api_key: str = Security(api_key_header)) -> bool:
+    if not api_key:
+        raise HTTPException(
+            status_code=HTTP_403_FORBIDDEN,
+            detail="No API key provided"
+        )
+        
+    # Clean the API key by removing 'Bearer ' if present
+    if api_key.startswith('Bearer '):
+        api_key = api_key[7:]  # Remove 'Bearer ' prefix
+        
+    # Get API keys from environment
+    valid_api_keys = get_env_vars()['api_keys']
+    if not valid_api_keys or valid_api_keys == ['']:
+        raise HTTPException(
+            status_code=HTTP_403_FORBIDDEN,
+            detail="API keys not configured on server"
+        )
+        
+    # Check if the provided key is valid
+    if api_key not in valid_api_keys:
+        raise HTTPException(
+            status_code=HTTP_403_FORBIDDEN,
+            detail="Invalid API key"
+        )
+        
+    return True
+
+# Cache for models.json
+@lru_cache(maxsize=1)
+async def get_models():
+    try:
+        file_path = Path(__file__).parent / 'models.json'
+        with open(file_path, 'r') as f:
+            return json.load(f)
+    except (FileNotFoundError, json.JSONDecodeError) as e:
+        # Log the error but don't expose the exact error to users
+        print(f"Error loading models.json: {str(e)}")
+        raise HTTPException(status_code=500, detail="Error loading available models")
+
+# Searcher function with optimized streaming
+def generate_search(query: str, systemprompt: Optional[str] = None, stream: bool = True) -> Generator[str, None, None]:
     headers = {"User-Agent": ""}
     
     # Use the provided system prompt, or default to "Be Helpful and Friendly"
@@ -173,8 +146,18 @@ def generate_search(query: str, systemprompt: Optional[str] = None, stream: bool
         "user_input": prompt[-1]["content"],
     }
     
+    # Get endpoint from environment
+    secret_api_endpoint_3 = get_env_vars()['secret_api_endpoint_3']
+    if not secret_api_endpoint_3:
+        raise ValueError("Search API endpoint not configured")
+    
     # Send the request to the chat endpoint
-    response = requests.post(secret_api_endpoint_3, headers=headers, json=payload, stream=True)
+    response = cloudscraper.create_scraper().post(
+        secret_api_endpoint_3, 
+        headers=headers, 
+        json=payload, 
+        stream=True
+    )
     
     streaming_text = ""
     
@@ -210,31 +193,21 @@ def generate_search(query: str, systemprompt: Optional[str] = None, stream: bool
     if not stream:
         yield streaming_text
 
+# Basic routes
+@app.get("/favicon.ico")
+async def favicon():
+    favicon_path = Path(__file__).parent / "favicon.ico"
+    return FileResponse(favicon_path, media_type="image/x-icon")
+
 @app.get("/ping")
 async def ping():
     start_time = datetime.datetime.now()
     response_time = (datetime.datetime.now() - start_time).total_seconds()
     return {"message": "pong", "response_time": f"{response_time:.6f} seconds"}
-    
-@app.get("/searchgpt")
-async def search_gpt(q: str, stream: Optional[bool] = False, systemprompt: Optional[str] = None):
-    if not q:
-        raise HTTPException(status_code=400, detail="Query parameter 'q' is required")
-    usage_tracker.record_request(endpoint="/searchgpt")
-    if stream:
-        return StreamingResponse(
-            generate_search(q, systemprompt=systemprompt, stream=True),
-            media_type="text/event-stream"
-        )
-    else:
-        # For non-streaming, collect the text and return as JSON response
-        response_text = "".join([chunk for chunk in generate_search(q, systemprompt=systemprompt, stream=False)])
-        return JSONResponse(content={"response": response_text})
+
 @app.get("/", response_class=HTMLResponse)
 async def root():
-    # Open and read the content of index.html (in the same folder as the app)
     file_path = "index.html"
-
     try:
         with open(file_path, "r") as file:
             html_content = file.read()
@@ -242,29 +215,55 @@ async def root():
     except FileNotFoundError:
         return HTMLResponse(content="<h1>File not found</h1>", status_code=404)
 
-async def get_models():
+@app.get("/playground", response_class=HTMLResponse)
+async def playground():
+    file_path = "playground.html"
     try:
-        # Load the models from models.json in the same folder
-        file_path = Path(__file__).parent / 'models.json'
-        with open(file_path, 'r') as f:
-            return json.load(f)
+        with open(file_path, "r") as file:
+            html_content = file.read()
+        return HTMLResponse(content=html_content)
     except FileNotFoundError:
-        raise HTTPException(status_code=404, detail="models.json not found")
-    except json.JSONDecodeError:
-        raise HTTPException(status_code=500, detail="Error decoding models.json")
-@app.get("api/v1/models")
+        return HTMLResponse(content="<h1>playground.html not found</h1>", status_code=404)
+
+# Model routes
+@app.get("/api/v1/models")
 @app.get("/models")
 async def return_models():
     return await get_models()
-server_status = True
+
+# Search routes
+@app.get("/searchgpt")
+async def search_gpt(q: str, stream: Optional[bool] = False, systemprompt: Optional[str] = None):
+    if not q:
+        raise HTTPException(status_code=400, detail="Query parameter 'q' is required")
+    
+    usage_tracker.record_request(endpoint="/searchgpt")
+    
+    if stream:
+        return StreamingResponse(
+            generate_search(q, systemprompt=systemprompt, stream=True),
+            media_type="text/event-stream"
+        )
+    else:
+        # For non-streaming, collect the text and return as JSON response
+        response_text = "".join([chunk for chunk in generate_search(q, systemprompt=systemprompt, stream=False)])
+        return JSONResponse(content={"response": response_text})
+
+# Chat completion endpoint
 @app.post("/chat/completions")
 @app.post("/api/v1/chat/completions")
 async def get_completion(payload: Payload, request: Request, authenticated: bool = Depends(verify_api_key)):
     # Check server status
+    if not server_status:
+        return JSONResponse(
+            status_code=503,
+            content={"message": "Server is under maintenance. Please try again later."}
+        )
+    
     model_to_use = payload.model if payload.model else "gpt-4o-mini"
 
     # Validate model availability
-    if model_to_use not in available_model_ids:
+    if available_model_ids and model_to_use not in available_model_ids:
         raise HTTPException(
             status_code=400,
             detail=f"Model '{model_to_use}' is not available. Check /models for the available model list."
@@ -276,31 +275,28 @@ async def get_completion(payload: Payload, request: Request, authenticated: bool
     payload_dict = payload.dict()
     payload_dict["model"] = model_to_use
 
+    # Get environment variables
+    env_vars = get_env_vars()
+
     # Select the appropriate endpoint
     if model_to_use in mistral_models:
-        endpoint = mistral_api
+        endpoint = env_vars['mistral_api']
         custom_headers = {
-            "Authorization": f"Bearer {mistral_key}"
+            "Authorization": f"Bearer {env_vars['mistral_key']}"
         }
     elif model_to_use in alternate_models:
-        endpoint = secret_api_endpoint_2
+        endpoint = env_vars['secret_api_endpoint_2']
         custom_headers = {}
     else:
-        endpoint = secret_api_endpoint
+        endpoint = env_vars['secret_api_endpoint']
         custom_headers = {}
 
-    # Current time and IP logging
+    # Current time and IP logging (with minimal data)
     current_time = (datetime.datetime.utcnow() + datetime.timedelta(hours=5, minutes=30)).strftime("%Y-%m-%d %I:%M:%S %p")
-    aaip = request.client.host
-    print(f"Time: {current_time}, {aaip}, {model_to_use}, server status: {server_status}")
-    print(payload_dict)
-
-    if not server_status:
-        return JSONResponse(
-            status_code=503,
-            content={"message": "Server is under maintenance. Please try again later."}
-        )
+    ip_hash = hash(request.client.host) % 10000  # Hash the IP for privacy
+    print(f"Time: {current_time}, IP Hash: {ip_hash}, Model: {model_to_use}")
 
+    # Create scraper for each connection to avoid concurrency issues
     scraper = cloudscraper.create_scraper()
 
     async def stream_generator(payload_dict):
@@ -314,55 +310,52 @@ async def get_completion(payload: Payload, request: Request, authenticated: bool
             )
 
             # Handle response errors
-            if response.status_code == 422:
-                raise HTTPException(status_code=422, detail="Unprocessable entity. Check your payload.")
-            elif response.status_code == 400:
-                raise HTTPException(status_code=400, detail="Bad request. Verify input data.")
-            elif response.status_code == 403:
-                raise HTTPException(status_code=403, detail="Forbidden. You do not have access to this resource.")
-            elif response.status_code == 404:
-                raise HTTPException(status_code=404, detail="The requested resource was not found.")
-            elif response.status_code >= 500:
-                raise HTTPException(status_code=500, detail="Server error. Try again later.")
+            if response.status_code >= 400:
+                error_messages = {
+                    422: "Unprocessable entity. Check your payload.",
+                    400: "Bad request. Verify input data.",
+                    403: "Forbidden. You do not have access to this resource.",
+                    404: "The requested resource was not found.",
+                }
+                detail = error_messages.get(response.status_code, f"Error code: {response.status_code}")
+                raise HTTPException(status_code=response.status_code, detail=detail)
 
             # Stream response lines to the client
             for line in response.iter_lines():
                 if line:
                     yield line.decode('utf-8') + "\n"
 
-        except requests.exceptions.RequestException as req_err:
-            print(response.text)
-            raise HTTPException(status_code=500, detail=f"Request failed: {req_err}")
         except Exception as e:
-            print(response.text)
-            raise HTTPException(status_code=500, detail=f"An unexpected error occurred: {e}")
+            # Use a generic error message that doesn't expose internal details
+            raise HTTPException(status_code=500, detail="An error occurred while processing your request")
 
     return StreamingResponse(stream_generator(payload_dict), media_type="application/json")
-# Remove the duplicated endpoint and combine the functionality
-@app.api_route("/images/generations", methods=["GET", "POST"])  # Support both GET and POST
+
+# Image generation endpoint
+@app.api_route("/images/generations", methods=["GET", "POST"])
 async def generate_image(
     prompt: Optional[str] = None, 
-    model: str = "flux",  # Default model
+    model: str = "flux",
     seed: Optional[int] = None,
     width: Optional[int] = None,
     height: Optional[int] = None,
     nologo: Optional[bool] = True,
     private: Optional[bool] = None,
     enhance: Optional[bool] = None,
-    request: Request = None,  # Access raw POST data
+    request: Request = None,
     authenticated: bool = Depends(verify_api_key)
 ):
-    """
-    Generate an image using the Image Generation API.
-    """
     # Validate the image endpoint
+    image_endpoint = get_env_vars()['image_endpoint']
     if not image_endpoint:
         raise HTTPException(status_code=500, detail="Image endpoint not configured in environment variables.")
+    
     usage_tracker.record_request(endpoint="/images/generations")
+    
     # Handle GET and POST prompts
     if request.method == "POST":
         try:
-            body = await request.json()  # Parse JSON body
+            body = await request.json()
             prompt = body.get("prompt", "").strip()
             if not prompt:
                 raise HTTPException(status_code=400, detail="Prompt cannot be empty")
@@ -377,12 +370,11 @@ async def generate_image(
     encoded_prompt = httpx.QueryParams({'prompt': prompt}).get('prompt')
 
     # Construct the URL with the encoded prompt
-    base_url = image_endpoint.rstrip('/')  # Remove trailing slash if present
+    base_url = image_endpoint.rstrip('/')
     url = f"{base_url}/{encoded_prompt}"
 
     # Prepare query parameters with validation
     params = {}
-
     if model and isinstance(model, str):
         params['model'] = model
     if seed is not None and isinstance(seed, int):
@@ -399,29 +391,25 @@ async def generate_image(
         params['enhance'] = str(enhance).lower()
 
     try:
-        timeout = httpx.Timeout(60.0)  # Set a reasonable timeout
-        async with httpx.AsyncClient(timeout=timeout) as client:
+        async with httpx.AsyncClient(timeout=60.0) as client:
             response = await client.get(url, params=params, follow_redirects=True)
 
             # Check for various error conditions
-            if response.status_code == 404:
-                raise HTTPException(status_code=404, detail="Image generation service not found")
-            elif response.status_code == 400:
-                raise HTTPException(status_code=400, detail="Invalid parameters provided to image service")
-            elif response.status_code == 429:
-                raise HTTPException(status_code=429, detail="Too many requests to image service")
-            elif response.status_code != 200:
-                raise HTTPException(
-                    status_code=response.status_code,
-                    detail=f"Image generation failed with status code {response.status_code}"
-                )
+            if response.status_code != 200:
+                error_messages = {
+                    404: "Image generation service not found",
+                    400: "Invalid parameters provided to image service",
+                    429: "Too many requests to image service",
+                }
+                detail = error_messages.get(response.status_code, f"Image generation failed with status code {response.status_code}")
+                raise HTTPException(status_code=response.status_code, detail=detail)
 
             # Verify content type
             content_type = response.headers.get('content-type', '')
             if not content_type.startswith('image/'):
                 raise HTTPException(
                     status_code=500,
-                    detail=f"Unexpected content type received: {content_type}"
+                    detail="Unexpected content type received from image service"
                 )
 
             return StreamingResponse(
@@ -435,35 +423,31 @@ async def generate_image(
 
     except httpx.TimeoutException:
         raise HTTPException(status_code=504, detail="Image generation request timed out")
-    except httpx.RequestError as e:
-        raise HTTPException(status_code=500, detail=f"Failed to contact image service: {str(e)}")
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Unexpected error during image generation: {str(e)}")
-@app.get("/playground", response_class=HTMLResponse)
-async def playground():
-    # Open and read the content of playground.html (in the same folder as the app)
-    file_path = "playground.html"
+    except httpx.RequestError:
+        raise HTTPException(status_code=500, detail="Failed to contact image service")
+    except Exception:
+        raise HTTPException(status_code=500, detail="Unexpected error during image generation")
 
+# Usage statistics
+@app.get("/meme")
+async def get_meme():
     try:
-        with open(file_path, "r") as file:
-            html_content = file.read()
-        return HTMLResponse(content=html_content)
-    except FileNotFoundError:
-        return HTMLResponse(content="<h1>playground.html not found</h1>", status_code=404)
-        
-def load_model_ids(json_file_path):
-    try:
-        with open(json_file_path, 'r') as f:
-            models_data = json.load(f)
-            # Extract 'id' from each model object
-            model_ids = [model['id'] for model in models_data if 'id' in model]
-            return model_ids
-    except FileNotFoundError:
-        print("Error: models.json file not found.")
-        return []
-    except json.JSONDecodeError:
-        print("Error: Invalid JSON format in models.json.")
-        return []
+        async with httpx.AsyncClient() as client:
+            response = await client.get("https://meme-api.com/gimme")
+            response_data = response.json()
+
+            meme_url = response_data.get("url")
+            if not meme_url:
+                raise HTTPException(status_code=404, detail="No meme found")
+
+            image_response = await client.get(meme_url, follow_redirects=True)
+            return StreamingResponse(
+                image_response.iter_bytes(), 
+                media_type=image_response.headers.get("content-type", "image/png")
+            )
+    except Exception:
+        raise HTTPException(status_code=500, detail="Failed to retrieve meme")
+
 @app.get("/usage")
 async def get_usage(days: int = 7):
     """Retrieve usage statistics"""
@@ -474,6 +458,7 @@ async def usage_page():
     """Serve an HTML page showing usage statistics"""
     # Retrieve usage data
     usage_data = usage_tracker.get_usage_summary()
+    
     # Model Usage Table Rows
     model_usage_rows = "\n".join([
         f"""
@@ -485,6 +470,7 @@ async def usage_page():
         </tr>
         """ for model, model_data in usage_data['models'].items()
     ])
+    
     # API Endpoint Usage Table Rows
     api_usage_rows = "\n".join([
         f"""
@@ -496,6 +482,7 @@ async def usage_page():
         </tr>
         """ for endpoint, endpoint_data in usage_data['api_endpoints'].items()
     ])
+    
     # Daily Usage Table Rows
     daily_usage_rows = "\n".join([
         "\n".join([
@@ -660,39 +647,40 @@ async def usage_page():
     </html>
     """
     return HTMLResponse(content=html_content)
-@app.get("/meme")
-async def get_meme():
-    try:
-        response = requests.get("https://meme-api.com/gimme")
-        response_data = response.json()
-
-        meme_url = response_data.get("url")
-
-        if meme_url:
-            def stream_image():
-                with requests.get(meme_url, stream=True) as image_response:
-                    for chunk in image_response.iter_content(chunk_size=1024):
-                        yield chunk
-
-            return StreamingResponse(stream_image(), media_type="image/png")
-        else:
-            raise HTTPException(status_code=404, detail="No mimi found :(")
 
+# Utility function for loading model IDs
+def load_model_ids(json_file_path):
+    try:
+        with open(json_file_path, 'r') as f:
+            models_data = json.load(f)
+            # Extract 'id' from each model object
+            model_ids = [model['id'] for model in models_data if 'id' in model]
+            return model_ids
     except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-        
+        print(f"Error loading model IDs: {str(e)}")
+        return []
+
 @app.on_event("startup")
 async def startup_event():
     global available_model_ids
     available_model_ids = load_model_ids("models.json")
-    print(f"Loaded model IDs: {available_model_ids}")
-    print("API endpoints:")
-    print("GET /")
-    print("GET /models")
-    print("GET /searchgpt")
-    print("POST /chat/completions")
-    print("GET /images/generations") 
+    print(f"Loaded {len(available_model_ids)} model IDs")
+    print("API started successfully")
     
+    # Validate critical environment variables
+    env_vars = get_env_vars()
+    missing_vars = []
+    
+    if not env_vars['secret_api_endpoint']:
+        missing_vars.append('SECRET_API_ENDPOINT')
+    if not env_vars['secret_api_endpoint_2']:
+        missing_vars.append('SECRET_API_ENDPOINT_2')
+    if not env_vars['secret_api_endpoint_3']:
+        missing_vars.append('SECRET_API_ENDPOINT_3')
+    
+    if missing_vars:
+        print(f"WARNING: The following required environment variables are missing: {', '.join(missing_vars)}")
+
 if __name__ == "__main__":
     import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=8000)
+    uvicorn.run(app, host="0.0.0.0", port=8000)