Upload 15 files

.dockerignore

@@ -0,0 +1,11 @@
+.git
+.env
+__pycache__/
+*.pyc
+.pytest_cache/
+.coverage
+.venv/
+venv/
+data/
+logs/
+*.log

Dockerfile

@@ -0,0 +1,11 @@
+FROM python:3.10-slim
+WORKDIR /app
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+COPY . .
+EXPOSE 7860
+EXPOSE 8000
+ENV PYTHONUNBUFFERED=1
+RUN useradd -m appuser
+USER appuser
+ENTRYPOINT ["python", "docker_entrypoint.py"]

app.py

@@ -0,0 +1,328 @@
+import os
+import sys
+import json
+import gradio as gr
+import asyncio
+import subprocess
+import threading
+import requests
+import time
+import random
+import string
+from typing import Dict, List, Optional
+import uuid
+
+from hf_utils import HuggingFaceSpaceHelper
+
+# Initialize helpers
+hf_helper = HuggingFaceSpaceHelper()
+
+# Install required packages for HF Spaces if needed
+if hf_helper.is_in_space:
+    hf_helper.install_dependencies([
+        "pymongo", "python-dotenv", "gradio", "requests"
+    ])
+
+# Import after potentially installing dependencies
+try:
+    from db_helper import MongoDBHelper
+    db = MongoDBHelper(hf_helper.get_mongodb_uri())
+except Exception as e:
+    print(f"Warning: MongoDB connection failed: {e}")
+    print("API key management will not work!")
+    db = None
+
+# Function to start the API in the background
+def start_api_server():
+    """Start the API server in a separate process"""
+    api_process = subprocess.Popen(
+        [sys.executable, "pyscout_api.py"],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True
+    )
+    return api_process
+
+# Determine the API base URL based on environment
+# In Docker, use the environment variable if set
+API_BASE_URL = os.getenv("API_BASE_URL", f"http://{hf_helper.get_hostname()}:8000")
+
+# Function to check API health
+def check_api_health():
+    """Check if the API is running and healthy"""
+    try:
+        response = requests.get(f"{API_BASE_URL}/health", timeout=5)
+        if response.status_code == 200:
+            return response.json()
+        return {"status": "error", "code": response.status_code}
+    except Exception as e:
+        return {"status": "error", "message": str(e)}
+
+# Utility functions for the Gradio UI
+def generate_api_key(email: str, name: str, organization: str = ""):
+    """Generate a new API key for a user"""
+    if not email or not name:
+        return "Error: Email and name are required"
+    
+    if not db:
+        # Generate a dummy key for demonstration if MongoDB is not connected
+        dummy_key = f"PyScoutAI-demo-{uuid.uuid4().hex[:16]}"
+        return f"Generated demo API key (MongoDB not connected):\n\n{dummy_key}\n\nThis key won't be validated in actual requests."
+    
+    try:
+        # Create a user ID from email
+        user_id = email.strip().lower()
+        
+        # Generate the API key
+        api_key = db.generate_api_key(user_id, name)
+        
+        return f"API key generated successfully:\n\n{api_key}\n\nStore this key safely. It won't be displayed again."
+        
+    except Exception as e:
+        return f"Error generating API key: {str(e)}"
+
+def list_user_api_keys(email: str):
+    """List all API keys for a user"""
+    if not email:
+        return "Error: Email is required"
+    
+    if not db:
+        return "Error: MongoDB not connected. Cannot list API keys."
+    
+    try:
+        # Get user ID from email
+        user_id = email.strip().lower()
+        
+        # Get all API keys for the user
+        keys = db.get_user_api_keys(user_id)
+        
+        if not keys:
+            return f"No API keys found for {email}"
+        
+        result = f"Found {len(keys)} API key(s) for {email}:\n\n"
+        for i, key in enumerate(keys):
+            status = "Active" if key.get("is_active", False) else "Revoked"
+            last_used = key.get("last_used", "Never")
+            if isinstance(last_used, str):
+                last_used_str = last_used
+            else:
+                last_used_str = last_used.strftime("%Y-%m-%d %H:%M:%S") if last_used else "Never"
+                
+            result += f"{i+1}. {key.get('name', 'Unnamed')} - {key.get('key')}\n"
+            result += f"   Status: {status}, Created: {key.get('created_at').strftime('%Y-%m-%d')}, "
+            result += f"Last used: {last_used_str}\n\n"
+        
+        return result
+        
+    except Exception as e:
+        return f"Error listing API keys: {str(e)}"
+
+def revoke_api_key(api_key: str):
+    """Revoke an API key"""
+    if not api_key:
+        return "Error: API key is required"
+    
+    if not db:
+        return "Error: MongoDB not connected. Cannot revoke API key."
+    
+    try:
+        if not api_key.startswith("PyScoutAI-"):
+            return "Error: Invalid API key format. Keys should start with 'PyScoutAI-'."
+            
+        success = db.revoke_api_key(api_key)
+        
+        if success:
+            return f"API key {api_key} revoked successfully"
+        else:
+            return f"API key {api_key} not found or already revoked"
+            
+    except Exception as e:
+        return f"Error revoking API key: {str(e)}"
+
+def test_api(api_key: str, prompt: str, model: str = "meta-llama/Llama-3.3-70B-Instruct-Turbo", temperature: float = 0.7):
+    """Test the API with a simple chat completion request"""
+    if not api_key:
+        return "Error: API key is required"
+    
+    if not prompt:
+        return "Error: Prompt is required"
+    
+    headers = {
+        "Content-Type": "application/json",
+        "Authorization": f"Bearer {api_key}"
+    }
+    
+    data = {
+        "model": model,
+        "messages": [
+            {"role": "system", "content": "You are a helpful assistant."},
+            {"role": "user", "content": prompt}
+        ],
+        "temperature": temperature
+    }
+    
+    try:
+        start_time = time.time()
+        response = requests.post(
+            f"{API_BASE_URL}/v1/chat/completions",
+            headers=headers,
+            json=data,
+            timeout=60
+        )
+        
+        elapsed = time.time() - start_time
+        
+        if response.status_code == 200:
+            result = response.json()
+            content = result["choices"][0]["message"]["content"]
+            tokens = result.get("usage", {}).get("total_tokens", "unknown")
+            
+            return f"Response (in {elapsed:.2f}s, {tokens} tokens):\n\n{content}"
+        else:
+            error_detail = "Unknown error"
+            try:
+                error_detail = response.json().get("detail", "Unknown error")
+            except:
+                error_detail = response.text
+                
+            return f"API Error (status {response.status_code}):\n{error_detail}"
+            
+    except requests.RequestException as e:
+        return f"Request error: {str(e)}"
+    except Exception as e:
+        return f"Unexpected error: {str(e)}"
+
+def list_models(api_key: str):
+    """List available models from the API"""
+    if not api_key:
+        return "Error: API key is required"
+    
+    headers = {
+        "Authorization": f"Bearer {api_key}"
+    }
+    
+    try:
+        response = requests.get(
+            f"{API_BASE_URL}/v1/models",
+            headers=headers,
+            timeout=10
+        )
+        
+        if response.status_code == 200:
+            models = response.json()
+            result = "Available models:\n\n"
+            for i, model in enumerate(models.get("data", [])):
+                result += f"{i+1}. {model.get('id')}\n"
+            return result
+        else:
+            error_detail = "Unknown error"
+            try:
+                error_detail = response.json().get("detail", "Unknown error")
+            except:
+                error_detail = response.text
+                
+            return f"API Error (status {response.status_code}):\n{error_detail}"
+            
+    except Exception as e:
+        return f"Error listing models: {str(e)}"
+
+def create_ui():
+    """Create the Gradio UI"""
+    with gr.Blocks(title="PyScoutAI API Manager") as app:
+        gr.Markdown("# PyScoutAI API Manager")
+        gr.Markdown("Manage API keys and test the PyScoutAI API")
+        
+        # API Status
+        with gr.Row():
+            check_api_btn = gr.Button("Check API Status")
+            api_status = gr.JSON(label="API Status")
+            check_api_btn.click(check_api_health, outputs=[api_status])
+        
+        with gr.Tabs():
+            # API Key Management Tab
+            with gr.TabItem("Manage API Keys"):
+                with gr.Tab("Generate API Key"):
+                    email_input = gr.Textbox(label="Email")
+                    name_input = gr.Textbox(label="Name")
+                    org_input = gr.Textbox(label="Organization (optional)")
+                    gen_key_btn = gr.Button("Generate API Key")
+                    key_output = gr.Textbox(label="Generated Key", lines=5)
+                    
+                    gen_key_btn.click(
+                        generate_api_key,
+                        inputs=[email_input, name_input, org_input],
+                        outputs=[key_output]
+                    )
+                
+                with gr.Tab("List User Keys"):
+                    email_list_input = gr.Textbox(label="Email")
+                    list_keys_btn = gr.Button("List API Keys")
+                    keys_output = gr.Textbox(label="User API Keys", lines=10)
+                    
+                    list_keys_btn.click(
+                        list_user_api_keys,
+                        inputs=[email_list_input],
+                        outputs=[keys_output]
+                    )
+                
+                with gr.Tab("Revoke API Key"):
+                    key_revoke_input = gr.Textbox(label="API Key to Revoke")
+                    revoke_btn = gr.Button("Revoke API Key")
+                    revoke_output = gr.Textbox(label="Result")
+                    
+                    revoke_btn.click(
+                        revoke_api_key,
+                        inputs=[key_revoke_input],
+                        outputs=[revoke_output]
+                    )
+            
+            # API Testing Tab
+            with gr.TabItem("Test API"):
+                with gr.Row():
+                    api_key_input = gr.Textbox(label="API Key")
+                    model_input = gr.Dropdown(
+                        choices=[
+                            "meta-llama/Llama-3.3-70B-Instruct-Turbo",
+                            "meta-llama/Meta-Llama-3.1-70B-Instruct",
+                            "mistralai/Mistral-Small-24B-Instruct-2501",
+                            "deepseek-ai/DeepSeek-V3"
+                        ],
+                        label="Model",
+                        value="meta-llama/Llama-3.3-70B-Instruct-Turbo"
+                    )
+                    temperature_input = gr.Slider(
+                        minimum=0.0,
+                        maximum=1.0,
+                        value=0.7,
+                        step=0.1,
+                        label="Temperature"
+                    )
+                
+                prompt_input = gr.Textbox(label="Prompt", lines=3)
+                test_btn = gr.Button("Send Request")
+                list_models_btn = gr.Button("List Available Models")
+                api_output = gr.Textbox(label="Response", lines=15)
+                
+                test_btn.click(
+                    test_api,
+                    inputs=[api_key_input, prompt_input, model_input, temperature_input],
+                    outputs=[api_output]
+                )
+                
+                list_models_btn.click(
+                    list_models,
+                    inputs=[api_key_input],
+                    outputs=[api_output]
+                )
+    
+    return app
+
+def main():
+    """Main entry point for the app"""
+    # Check if API server is running
+    api_health = check_api_health()
+    
+    if "status" in api_health and api_health["status"] == "error":
+        print("API server doesn't seem to be running. Starting it...")
+        # Start the API server if it's not already running
+        api_process = start_api_server()

client_example.py

@@ -0,0 +1,181 @@
+import os
+import json
+import time
+from typing import Dict, List, Any
+from rich import print
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+
+from deepinfra_client import DeepInfraClient
+
+console = Console()
+
+def print_proxy_status(client):
+    """Print the proxy and IP rotation status"""
+    status = []
+    
+    if client.use_proxy_rotation and client.proxy_finder:
+        proxy_counts = {k: len(v) for k, v in client.proxy_finder.proxy_dict.items()}
+        total_proxies = sum(proxy_counts.values())
+        status.append(f"Proxy rotation: [green]Enabled[/green] ({total_proxies} proxies)")
+        
+        # Show available proxies per type
+        table = Table(title="Available Proxies")
+        table.add_column("Type", style="cyan")
+        table.add_column("Count", style="green")
+        
+        for proxy_type, count in proxy_counts.items():
+            if count > 0:
+                table.add_row(proxy_type, str(count))
+        
+        console.print(table)
+    else:
+        status.append("Proxy rotation: [red]Disabled[/red]")
+    
+    if client.use_ip_rotation and client.ip_rotator:
+        status.append(f"IP rotation: [green]Enabled[/green] (AWS API Gateway - {len(client.ip_rotator.gateways)} regions)")
+    else:
+        status.append("IP rotation: [red]Disabled[/red]")
+        
+    if client.use_random_user_agent:
+        status.append("User-Agent rotation: [green]Enabled[/green]")
+    else:
+        status.append("User-Agent rotation: [red]Disabled[/red]")
+    
+    console.print(Panel("\n".join(status), title="Client Configuration", border_style="blue"))
+
+def chat_with_model():
+    """Demonstrate interactive chat with DeepInfra models"""
+    # Initialize the client with all rotation features enabled
+    client = DeepInfraClient(
+        api_key=os.getenv("DEEPINFRA_API_KEY"),  # Set this environment variable if you have an API key
+        use_random_user_agent=True,
+        use_ip_rotation=True,
+        use_proxy_rotation=True,
+        proxy_types=['http', 'socks5'],
+        model="meta-llama/Llama-3.3-70B-Instruct-Turbo"  # Use a good default model
+    )
+    
+    print_proxy_status(client)
+    
+    # Show available models
+    console.print("\n[bold cyan]Fetching available models...[/bold cyan]")
+    try:
+        models_response = client.models.list()
+        model_table = Table(title="Available Models")
+        model_table.add_column("Model", style="green")
+        
+        for model in models_response["data"]:
+            model_table.add_row(model["id"])
+            
+        console.print(model_table)
+    except Exception as e:
+        console.print(f"[red]Error fetching models: {str(e)}[/red]")
+    
+    # Start interactive chat
+    console.print("\n[bold green]Starting interactive chat (type 'quit' to exit)[/bold green]")
+    console.print("[yellow]Note: Every 3 messages, the client will rotate IP and proxy[/yellow]\n")
+    
+    messages = [{"role": "system", "content": "You are a helpful assistant."}]
+    message_count = 0
+    
+    while True:
+        user_input = input("\nYou: ")
+        if user_input.lower() in ["quit", "exit", "bye"]:
+            break
+            
+        messages.append({"role": "user", "content": user_input})
+        
+        # Rotate IP and proxy every 3 messages
+        message_count += 1
+        if message_count % 3 == 0:
+            console.print("[yellow]Rotating IP and proxy...[/yellow]")
+            client.refresh_proxies()
+            client.refresh_session()
+        
+        # Make the API call
+        console.print("\n[cyan]Waiting for response...[/cyan]")
+        start_time = time.time()
+        
+        try:
+            response = client.chat.create(
+                messages=messages,
+                temperature=0.7,
+                max_tokens=1024
+            )
+            
+            elapsed = time.time() - start_time
+            assistant_message = response["choices"][0]["message"]["content"]
+            
+            # Add the assistant's message to our history
+            messages.append({"role": "assistant", "content": assistant_message})
+            
+            console.print(f"\n[bold green]Assistant[/bold green] [dim]({elapsed:.2f}s)[/dim]:")
+            console.print(assistant_message)
+            
+        except Exception as e:
+            console.print(f"[bold red]Error: {str(e)}[/bold red]")
+            console.print("[yellow]Refreshing session and trying again...[/yellow]")
+            client.refresh_session()
+
+def stream_example():
+    """Demonstrate streaming responses"""
+    client = DeepInfraClient(
+        use_random_user_agent=True,
+        use_ip_rotation=True,
+        use_proxy_rotation=True
+    )
+    
+    print_proxy_status(client)
+    
+    prompt = "Write a short story about a robot that learns to feel emotions."
+    
+    console.print(f"\n[bold cyan]Prompt:[/bold cyan] {prompt}")
+    console.print("\n[bold green]Streaming response:[/bold green]")
+    
+    try:
+        response_stream = client.completions.create(
+            prompt=prompt,
+            temperature=0.8,
+            max_tokens=1024,
+            stream=True
+        )
+        
+        full_response = ""
+        for chunk in response_stream:
+            if 'choices' in chunk and len(chunk['choices']) > 0:
+                delta = chunk['choices'][0].get('delta', {})
+                if 'content' in delta:
+                    content = delta['content']
+                    print(content, end='', flush=True)
+                    full_response += content
+        print("\n")
+        
+    except Exception as e:
+        console.print(f"\n[bold red]Error: {str(e)}[/bold red]")
+
+if __name__ == "__main__":
+    console.print(Panel.fit(
+        "[bold green]DeepInfra Client Example[/bold green]\n"
+        "This example demonstrates the enhanced client with proxy and IP rotation",
+        border_style="yellow"
+    ))
+    
+    while True:
+        console.print("\n[bold cyan]Choose an option:[/bold cyan]")
+        console.print("1. Interactive Chat")
+        console.print("2. Streaming Example")
+        console.print("3. Exit")
+        
+        choice = input("\nEnter your choice (1-3): ")
+        
+        if choice == "1":
+            chat_with_model()
+        elif choice == "2":
+            stream_example()
+        elif choice == "3":
+            console.print("[yellow]Exiting...[/yellow]")
+            break
+        else:
+            console.print("[red]Invalid choice. Please try again.[/red]")

db_helper.py

@@ -0,0 +1,266 @@
+import os
+import uuid
+import datetime
+from typing import Dict, List, Optional, Any
+from pymongo import MongoClient
+from bson.objectid import ObjectId
+
+class MongoDBHelper:
+    """Helper class for MongoDB operations"""
+    
+    def __init__(self, connection_string: Optional[str] = None):
+        """Initialize the MongoDB client"""
+        # Get connection string from env var or use provided one
+        self.connection_string = connection_string or os.getenv('MONGODB_URI')
+        
+        if not self.connection_string:
+            raise ValueError("MongoDB connection string not provided. Set MONGODB_URI environment variable or pass it to constructor.")
+            
+        self.client = MongoClient(self.connection_string)
+        self.db = self.client.get_database("pyscout_ai")
+        
+        # Collections
+        self.api_keys_collection = self.db.api_keys
+        self.usage_collection = self.db.usage
+        self.users_collection = self.db.users
+        self.conversations_collection = self.db.conversations
+        self.messages_collection = self.db.messages
+        
+        self._create_indexes()
+    
+    def _create_indexes(self):
+        # API Keys indexes
+        self.api_keys_collection.create_index("key", unique=True)
+        self.api_keys_collection.create_index("user_id")
+        self.api_keys_collection.create_index("created_at")
+        
+        # Usage indexes
+        self.usage_collection.create_index("api_key")
+        self.usage_collection.create_index("timestamp")
+        
+        # Users indexes
+        self.users_collection.create_index("email", unique=True)
+        
+        # Conversations indexes
+        self.conversations_collection.create_index("user_id")
+        self.conversations_collection.create_index("created_at")
+        
+        # Messages indexes
+        self.messages_collection.create_index("conversation_id")
+        self.messages_collection.create_index("timestamp")
+
+    def create_user(self, email: str, name: str, organization: str = None) -> str:
+        user_id = str(ObjectId())
+        self.users_collection.insert_one({
+            "_id": ObjectId(user_id),
+            "email": email,
+            "name": name,
+            "organization": organization,
+            "created_at": datetime.datetime.utcnow(),
+            "last_active": datetime.datetime.utcnow()
+        })
+        return user_id
+
+    def create_conversation(self, user_id: str, system_prompt: str = None) -> str:
+        conversation_id = str(ObjectId())
+        self.conversations_collection.insert_one({
+            "_id": ObjectId(conversation_id),
+            "user_id": user_id,
+            "system_prompt": system_prompt,
+            "created_at": datetime.datetime.utcnow(),
+            "last_message_at": datetime.datetime.utcnow(),
+            "is_active": True
+        })
+        return conversation_id
+
+    def add_message(self, conversation_id: str, role: str, content: str, 
+                   model: str = None, tokens: int = 0) -> str:
+        message_id = str(ObjectId())
+        self.messages_collection.insert_one({
+            "_id": ObjectId(message_id),
+            "conversation_id": conversation_id,
+            "role": role,
+            "content": content,
+            "model": model,
+            "tokens": tokens,
+            "timestamp": datetime.datetime.utcnow()
+        })
+        
+        # Update conversation last_message_at
+        self.conversations_collection.update_one(
+            {"_id": ObjectId(conversation_id)},
+            {"$set": {"last_message_at": datetime.datetime.utcnow()}}
+        )
+        
+        return message_id
+
+    def get_conversation_history(self, conversation_id: str) -> List[Dict]:
+        return list(self.messages_collection.find(
+            {"conversation_id": conversation_id},
+            {"_id": 0}
+        ).sort("timestamp", 1))
+
+    def get_user_conversations(self, user_id: str, limit: int = 10) -> List[Dict]:
+        conversations = list(self.conversations_collection.find(
+            {"user_id": user_id},
+            {"_id": 1, "system_prompt": 1, "created_at": 1, "last_message_at": 1}
+        ).sort("last_message_at", -1).limit(limit))
+        
+        # Convert ObjectId to string
+        for conv in conversations:
+            conv["_id"] = str(conv["_id"])
+        return conversations
+
+    def generate_api_key(self, user_id: str, name: str = "Default API Key") -> str:
+        """Generate a new API key for a user"""
+        # Format: PyScoutAI-{uuid4-hex}
+        api_key = f"PyScoutAI-{uuid.uuid4().hex}"
+        
+        # Store in database
+        self.api_keys_collection.insert_one({
+            "key": api_key,
+            "user_id": user_id,
+            "name": name,
+            "created_at": datetime.datetime.utcnow(),
+            "last_used": None,
+            "is_active": True,
+            "rate_limit": {
+                "requests_per_day": 1000,
+                "tokens_per_day": 1000000
+            }
+        })
+        
+        return api_key
+    
+    def validate_api_key(self, api_key: str) -> Dict[str, Any]:
+        """
+        Validate an API key
+        
+        Returns:
+            Dict with user info if valid, None otherwise
+        """
+        if not api_key:
+            return None
+            
+        # Find the API key in the database
+        key_data = self.api_keys_collection.find_one({"key": api_key, "is_active": True})
+        if not key_data:
+            return None
+            
+        # Update last used timestamp
+        self.api_keys_collection.update_one(
+            {"_id": key_data["_id"]},
+            {"$set": {"last_used": datetime.datetime.utcnow()}}
+        )
+        
+        return key_data
+    
+    def log_api_usage(self, api_key: str, endpoint: str, tokens: int = 0, 
+                     model: str = None, conversation_id: str = None):
+        usage_data = {
+            "api_key": api_key,
+            "endpoint": endpoint,
+            "tokens": tokens,
+            "model": model,
+            "timestamp": datetime.datetime.utcnow()
+        }
+        if conversation_id:
+            usage_data["conversation_id"] = conversation_id
+            
+        self.usage_collection.insert_one(usage_data)
+
+    def get_user_api_keys(self, user_id: str) -> List[Dict[str, Any]]:
+        """Get all API keys for a user"""
+        keys = list(self.api_keys_collection.find({"user_id": user_id}))
+        # Convert ObjectId to string for JSON serialization
+        for key in keys:
+            key["_id"] = str(key["_id"])
+        return keys
+    
+    def revoke_api_key(self, api_key: str) -> bool:
+        """Revoke an API key"""
+        result = self.api_keys_collection.update_one(
+            {"key": api_key},
+            {"$set": {"is_active": False}}
+        )
+        return result.modified_count > 0
+    
+    def check_rate_limit(self, api_key: str) -> Dict[str, Any]:
+        """
+        Check if the API key has exceeded its rate limits
+        
+        Returns:
+            Dict with rate limit info and allowed status
+        """
+        key_data = self.api_keys_collection.find_one({"key": api_key, "is_active": True})
+        if not key_data:
+            return {"allowed": False, "reason": "Invalid API key"}
+            
+        # Get rate limit settings
+        rate_limit = key_data.get("rate_limit", {})
+        requests_per_day = rate_limit.get("requests_per_day", 1000)
+        tokens_per_day = rate_limit.get("tokens_per_day", 1000000)
+        
+        # Calculate usage for today
+        today_start = datetime.datetime.combine(
+            datetime.datetime.utcnow().date(),
+            datetime.time.min
+        )
+        
+        # Count requests today
+        requests_today = self.usage_collection.count_documents({
+            "api_key": api_key,
+            "timestamp": {"$gte": today_start}
+        })
+        
+        # Sum tokens used today
+        tokens_pipeline = [
+            {"$match": {"api_key": api_key, "timestamp": {"$gte": today_start}}},
+            {"$group": {"_id": None, "total_tokens": {"$sum": "$tokens"}}}
+        ]
+        tokens_result = list(self.usage_collection.aggregate(tokens_pipeline))
+        tokens_today = tokens_result[0]["total_tokens"] if tokens_result else 0
+        
+        # Check if limits are exceeded
+        if requests_today >= requests_per_day:
+            return {
+                "allowed": False,
+                "reason": "Daily request limit exceeded",
+                "limit": requests_per_day,
+                "used": requests_today
+            }
+            
+        if tokens_today >= tokens_per_day:
+            return {
+                "allowed": False,
+                "reason": "Daily token limit exceeded",
+                "limit": tokens_per_day,
+                "used": tokens_today
+            }
+            
+        return {
+            "allowed": True,
+            "requests": {
+                "limit": requests_per_day,
+                "used": requests_today,
+                "remaining": requests_per_day - requests_today
+            },
+            "tokens": {
+                "limit": tokens_per_day,
+                "used": tokens_today,
+                "remaining": tokens_per_day - tokens_today
+            }
+        }
+
+    def get_user_stats(self, user_id: str) -> Dict:
+        pipeline = [
+            {"$match": {"user_id": user_id}},
+            {"$group": {
+                "_id": None,
+                "total_conversations": {"$sum": 1},
+                "total_messages": {"$sum": "$message_count"},
+                "total_tokens": {"$sum": "$total_tokens"}
+            }}
+        ]
+        stats = list(self.conversations_collection.aggregate(pipeline))
+        return stats[0] if stats else {"total_conversations": 0, "total_messages": 0, "total_tokens": 0}

deepinfra_client.py

@@ -0,0 +1,473 @@
+import requests
+import json
+import os
+import random
+import time
+from typing import Any, Dict, Optional, Generator, Union, List
+import warnings
+from fake_useragent import UserAgent
+from requests_ip_rotator import ApiGateway
+from proxy_finder import ProxyFinder
+
+class IPRotator:
+    """Manages AWS API Gateway rotation for multiple regions"""
+    
+    def __init__(self, target_url="deepinfra.com", regions=None):
+        """Initialize with target URL and regions"""
+        self.target_url = target_url
+        self.regions = regions or ["us-east-1", "us-west-1", "eu-west-1", "ap-southeast-1"]
+        self.gateways = {}
+        
+    def setup(self):
+        """Set up API gateways for each region"""
+        for region in self.regions:
+            try:
+                gateway = ApiGateway(self.target_url, region=region)
+                gateway.start()
+                self.gateways[region] = gateway
+            except Exception as e:
+                print(f"Failed to set up gateway in {region}: {str(e)}")
+        
+        if not self.gateways:
+            raise Exception("Failed to set up any API gateways for IP rotation")
+    
+    def get_session(self):
+        """Get a random session from a gateway"""
+        if not self.gateways:
+            return requests.Session()
+            
+        # Choose a random gateway
+        region = random.choice(list(self.gateways.keys()))
+        gateway = self.gateways[region]
+        return gateway.get_session()
+    
+    def shutdown(self):
+        """Clean up all gateways"""
+        for gateway in self.gateways.values():
+            try:
+                gateway.shutdown()
+            except:
+                pass
+
+class ProxyManager:
+    """Manages proxy rotation for HTTP requests"""
+    
+    def __init__(self, proxies=None):
+        """Initialize with a list of proxies or an empty list"""
+        self.proxies = proxies or []
+        
+    def add_proxy(self, proxy):
+        """Add a proxy to the list"""
+        self.proxies.append(proxy)
+        
+    def get_random(self):
+        """Return a random proxy if available, otherwise None"""
+        if not self.proxies:
+            return None
+        return random.choice(self.proxies)
+
+class DeepInfraClient:
+    """
+    A client for DeepInfra API with OpenAI-compatible interface and enhanced features
+    """
+
+    AVAILABLE_MODELS = [
+        "deepseek-ai/DeepSeek-R1-Turbo",
+        "deepseek-ai/DeepSeek-R1",
+        "deepseek-ai/DeepSeek-R1-Distill-Llama-70B",
+        "deepseek-ai/DeepSeek-V3",
+        "meta-llama/Llama-3.3-70B-Instruct-Turbo",
+        "mistralai/Mistral-Small-24B-Instruct-2501",
+        "deepseek-ai/DeepSeek-R1-Distill-Qwen-32B",
+        "microsoft/phi-4",
+        "meta-llama/Meta-Llama-3.1-70B-Instruct",
+        "meta-llama/Meta-Llama-3.1-8B-Instruct",
+        "meta-llama/Meta-Llama-3.1-405B-Instruct",
+        "meta-llama/Meta-Llama-3.1-8B-Instruct-Turbo",
+        "meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo",
+        "Qwen/Qwen2.5-Coder-32B-Instruct",
+        "nvidia/Llama-3.1-Nemotron-70B-Instruct",
+        "Qwen/Qwen2.5-72B-Instruct",
+        "meta-llama/Llama-3.2-90B-Vision-Instruct",
+        "meta-llama/Llama-3.2-11B-Vision-Instruct",
+        "Gryphe/MythoMax-L2-13b",
+        "NousResearch/Hermes-3-Llama-3.1-405B",
+        "NovaSky-AI/Sky-T1-32B-Preview",
+        "Qwen/Qwen2.5-7B-Instruct",
+        "Sao10K/L3.1-70B-Euryale-v2.2",
+        "Sao10K/L3.3-70B-Euryale-v2.3",
+        "google/gemma-2-27b-it",
+        "google/gemma-2-9b-it",
+        "meta-llama/Llama-3.2-1B-Instruct",
+        "meta-llama/Llama-3.2-3B-Instruct",
+        "meta-llama/Meta-Llama-3-70B-Instruct",
+        "meta-llama/Meta-Llama-3-8B-Instruct",
+        "mistralai/Mistral-Nemo-Instruct-2407",
+        "mistralai/Mistral-7B-Instruct-v0.3",
+        "mistralai/Mixtral-8x7B-Instruct-v0.1"
+    ]
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        base_url: str = "https://api.deepinfra.com/v1",
+        timeout: int = 30,
+        max_tokens: int = 2049,
+        model: str = "meta-llama/Llama-3.3-70B-Instruct-Turbo",
+        use_random_user_agent: bool = True,
+        use_proxy_rotation: bool = True,
+        use_ip_rotation: bool = True,
+        proxy_types: List[str] = None
+    ):
+        """Initialize the DeepInfraClient"""
+        self.base_url = base_url
+        self.api_key = api_key
+        self.model = model
+        self.timeout = timeout
+        self.max_tokens = max_tokens
+        self.use_random_user_agent = use_random_user_agent
+        self.use_ip_rotation = use_ip_rotation
+        self.use_proxy_rotation = use_proxy_rotation
+        self.proxy_types = proxy_types or ['http', 'socks5'] # Default proxy types
+        
+        # Initialize user agent generator
+        self.user_agent = UserAgent()
+        
+        # Set up proxy finder and get initial proxies if proxy rotation is enabled
+        self.proxy_finder = None
+        if self.use_proxy_rotation:
+            self.proxy_finder = ProxyFinder(verbose=False)
+            self.proxy_finder.get_proxies(self.proxy_types)
+        
+        # Set up IP rotator if enabled
+        self.ip_rotator = None
+        if use_ip_rotation:
+            try:
+                self.ip_rotator = IPRotator(target_url="deepinfra.com")
+                self.ip_rotator.setup()
+            except Exception as e:
+                print(f"Failed to set up IP rotation: {e}. Continuing without IP rotation.")
+                self.ip_rotator = None
+            
+        # Set up headers with random or fixed user agent
+        self.headers = self._create_headers()
+        
+        # Initialize session based on available rotation methods
+        if self.use_ip_rotation and self.ip_rotator:
+            self.session = self.ip_rotator.get_session()
+        else:
+            self.session = requests.Session()
+            
+        self.session.headers.update(self.headers)
+        
+        # Apply proxy if proxy rotation is enabled
+        if self.use_proxy_rotation and self.proxy_finder:
+            self._apply_random_proxy()
+        
+        # Resources
+        self.models = Models(self)
+        self.chat = ChatCompletions(self)
+        self.completions = Completions(self)
+        
+    def _create_headers(self) -> Dict[str, str]:
+        """Create headers for the HTTP request, optionally with a random user agent"""
+        user_agent = self.user_agent.random if self.use_random_user_agent else \
+            'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36'
+        
+        headers = {
+            'User-Agent': user_agent,
+            'Accept-Language': 'en-US,en;q=0.9',
+            'Cache-Control': 'no-cache',
+            'Connection': 'keep-alive',
+            'Content-Type': 'application/json',
+            'Origin': 'https://deepinfra.com',
+            'Referer': 'https://deepinfra.com/',
+            'Sec-Fetch-Dest': 'empty',
+            'Sec-Fetch-Mode': 'cors',
+            'Sec-Fetch-Site': 'same-site',
+            'X-Deepinfra-Source': 'web-embed',
+            'accept': 'text/event-stream',
+            'sec-ch-ua-mobile': '?0',
+            'sec-ch-ua-platform': '"macOS"'
+        }
+        
+        if self.api_key:
+            headers['Authorization'] = f"Bearer {self.api_key}"
+            
+        return headers
+    
+    def _apply_random_proxy(self):
+        """Apply a random proxy to the current session"""
+        if not self.proxy_finder:
+            return False
+            
+        # First try to get a proxy of preferred type (http/https first, then socks5)
+        for proxy_type in self.proxy_types:
+            proxy = self.proxy_finder.get_random_proxy(proxy_type)
+            if proxy:
+                if proxy_type in ['http', 'https']:
+                    self.session.proxies.update({
+                        "http": f"http://{proxy}",
+                        "https": f"http://{proxy}"
+                    })
+                    return True
+                elif proxy_type == 'socks4':
+                    self.session.proxies.update({
+                        "http": f"socks4://{proxy}",
+                        "https": f"socks4://{proxy}"
+                    })
+                    return True
+                elif proxy_type == 'socks5':
+                    self.session.proxies.update({
+                        "http": f"socks5://{proxy}",
+                        "https": f"socks5://{proxy}"
+                    })
+                    return True
+        
+        # If no proxy found, return False
+        return False
+    
+    def refresh_session(self):
+        """Refresh the session with new headers and possibly a new proxy or IP"""
+        if self.use_random_user_agent:
+            self.headers['User-Agent'] = self.user_agent.random
+            
+        # Apply a random proxy if proxy rotation is enabled
+        if self.use_proxy_rotation and self.proxy_finder:
+            proxy_applied = self._apply_random_proxy()
+            # If no proxy was applied, try to get new proxies
+            if not proxy_applied:
+                self.proxy_finder.get_proxies(self.proxy_types)
+                self._apply_random_proxy()
+        
+        # Rotate IP if enabled
+        if self.use_ip_rotation and self.ip_rotator:
+            self.session = self.ip_rotator.get_session()
+            
+        self.session.headers.update(self.headers)
+        
+    def _request(self, method: str, endpoint: str, **kwargs) -> requests.Response:
+        """Make an HTTP request with automatic retry and proxy/user-agent rotation"""
+        url = f"{self.base_url}/{endpoint.lstrip('/')}"
+        max_retries = 3
+        retry_delay = 1
+        
+        for attempt in range(max_retries):
+            try:
+                response = self.session.request(method, url, **kwargs)
+                response.raise_for_status()
+                return response
+            except requests.RequestException as e:
+                if attempt < max_retries - 1:
+                    self.refresh_session()
+                    time.sleep(retry_delay * (attempt + 1))
+                    continue
+                raise e
+    
+    def refresh_proxies(self):
+        """Refresh all proxies by fetching new ones"""
+        if self.proxy_finder:
+            self.proxy_finder.get_proxies(self.proxy_types)
+            self._apply_random_proxy()
+            return True
+        return False
+        
+    def __del__(self):
+        """Clean up resources on deletion"""
+        if self.ip_rotator:
+            try:
+                self.ip_rotator.shutdown()
+            except:
+                pass
+
+class Models:
+    def __init__(self, client: DeepInfraClient):
+        self.client = client
+        
+    def list(self) -> Dict[str, Any]:
+        """Get available models, similar to OpenAI's /v1/models endpoint"""
+        model_data = []
+        for model_id in self.client.AVAILABLE_MODELS:
+            model_data.append({
+                "id": model_id,
+                "object": "model",
+                "created": 1677610602,
+                "owned_by": "deepinfra"
+            })
+        
+        return {
+            "object": "list",
+            "data": model_data
+        }
+
+class ChatCompletions:
+    def __init__(self, client: DeepInfraClient):
+        self.client = client
+    
+    def create(
+        self,
+        messages: List[Dict[str, str]],
+        model: str = None,
+        temperature: float = 0.7,
+        max_tokens: int = None,
+        stream: bool = False,
+        **kwargs
+    ) -> Union[Dict[str, Any], Generator[Dict[str, Any], None, None]]:
+        """Create a chat completion, similar to OpenAI's chat/completions endpoint"""
+        model = model or self.client.model
+        max_tokens = max_tokens or self.client.max_tokens
+        
+        url = "openai/chat/completions"
+        
+        # Prepare the payload for the API request
+        payload = {
+            "model": model,
+            "messages": messages,
+            "temperature": temperature,
+            "max_tokens": max_tokens,
+            "stream": stream
+        }
+        
+        # Add any additional parameters
+        payload.update({k: v for k, v in kwargs.items() if v is not None})
+        
+        if stream:
+            return self._handle_stream(url, payload)
+        else:
+            return self._handle_request(url, payload)
+    
+    def _handle_request(self, url: str, payload: Dict[str, Any]) -> Dict[str, Any]:
+        """Handle non-streaming requests"""
+        try:
+            response = self.client._request(
+                "POST",
+                url,
+                json=payload,
+                timeout=self.client.timeout
+            )
+            return response.json()
+        except requests.RequestException as e:
+            error_message = f"Request failed: {str(e)}"
+            if hasattr(e, 'response') and e.response is not None:
+                try:
+                    error_data = e.response.json()
+                    if 'error' in error_data:
+                        error_message = f"API error: {error_data['error']}"
+                except:
+                    error_message = f"API error: {e.response.text}"
+            
+            raise Exception(error_message)
+    
+    def _handle_stream(self, url: str, payload: Dict[str, Any]) -> Generator[Dict[str, Any], None, None]:
+        """Handle streaming requests"""
+        try:
+            response = self.client._request(
+                "POST", 
+                url,
+                json=payload,
+                stream=True,
+                timeout=self.client.timeout
+            )
+            
+            for line in response.iter_lines(decode_unicode=True):
+                if line:
+                    line = line.strip()
+                    if line.startswith("data: "):
+                        json_str = line[6:]
+                        if json_str == "[DONE]":
+                            break
+                        try:
+                            json_data = json.loads(json_str)
+                            yield json_data
+                        except json.JSONDecodeError:
+                            continue
+        except requests.RequestException as e:
+            error_message = f"Stream request failed: {str(e)}"
+            if hasattr(e, 'response') and e.response is not None:
+                try:
+                    error_data = e.response.json()
+                    if 'error' in error_data:
+                        error_message = f"API error: {error_data['error']}"
+                except:
+                    error_message = f"API error: {e.response.text}"
+            
+            raise Exception(error_message)
+
+class Completions:
+    def __init__(self, client: DeepInfraClient):
+        self.client = client
+    
+    def create(
+        self,
+        prompt: str,
+        model: str = None,
+        temperature: float = 0.7,
+        max_tokens: int = None,
+        stream: bool = False,
+        **kwargs
+    ) -> Union[Dict[str, Any], Generator[Dict[str, Any], None, None]]:
+        """Create a completion, similar to OpenAI's completions endpoint"""
+        # Convert prompt to messages format for chat models
+        messages = [{"role": "user", "content": prompt}]
+        
+        return self.client.chat.create(
+            messages=messages,
+            model=model,
+            temperature=temperature,
+            max_tokens=max_tokens,
+            stream=stream,
+            **kwargs
+        )
+
+if __name__ == "__main__":
+    import time
+    from rich import print
+    
+    # Example with random user agent, proxy rotation and IP rotation
+    client = DeepInfraClient(
+        use_random_user_agent=True,
+        use_ip_rotation=True,
+        use_proxy_rotation=True,
+        proxy_types=['http', 'socks5']
+    )
+    
+    # Get available models
+    models_response = client.models.list()
+    print("Available models:")
+    for model in models_response["data"][:5]:  # Print first 5 models
+        print(f"- {model['id']}")
+    print("...")
+    
+    # Non-streaming chat completion
+    chat_response = client.chat.create(
+        messages=[
+            {"role": "system", "content": "You are a helpful assistant."},
+            {"role": "user", "content": "Write a short poem about AI"}
+        ]
+    )
+    print("\nNon-streaming response:")
+    print(chat_response["choices"][0]["message"]["content"])
+    
+    # Refresh proxies and try again with another request
+    print("\nRefreshing proxies and making another request...")
+    client.refresh_proxies()
+    client.refresh_session()
+    
+    streaming_response = client.chat.create(
+        messages=[
+            {"role": "system", "content": "You are a helpful assistant."},
+            {"role": "user", "content": "Tell me about the future of AI in 3 sentences."}
+        ],
+        stream=True
+    )
+    
+    print("\nStreaming response:")
+    full_response = ""
+    for chunk in streaming_response:
+        if 'choices' in chunk and len(chunk['choices']) > 0:
+            delta = chunk['choices'][0].get('delta', {})
+            if 'content' in delta:
+                content = delta['content']
+                print(content, end='', flush=True)
+                full_response += content
+    print("\n")

docker-compose.override.yml.example

@@ -0,0 +1,39 @@
+# Example override file for docker-compose.yml
+# Copy this file to docker-compose.override.yml and edit as needed
+
+version: '3.8'
+
+services:
+  # MongoDB service customization
+  mongodb:
+    # Example: Expose MongoDB port locally for debugging
+    ports:
+      - "27017:27017"
+    # Example: Add authentication
+    environment:
+      MONGO_INITDB_ROOT_USERNAME: your_custom_username
+      MONGO_INITDB_ROOT_PASSWORD: your_custom_password
+    # Example: Persistent volume on host
+    volumes:
+      - ./mongodb_data:/data/db
+
+  # PyScout API service customization
+  pyscout-api:
+    # Example: Use a different port
+    ports:
+      - "8080:8000"
+    # Example: Add debugging
+    environment:
+      - DEBUG=True
+      - LOG_LEVEL=DEBUG
+      - MONGODB_URI=mongodb://your_custom_username:your_custom_password@mongodb:27017/pyscout_ai?authSource=admin
+
+  # Gradio UI service customization
+  gradio-ui:
+    # Example: Use a different port
+    ports:
+      - "7000:7860"
+    # Example: Enable share link
+    environment:
+      - GRADIO_SHARE=true
+      - API_BASE_URL=http://pyscout-api:8000

docker-compose.yml

@@ -0,0 +1,33 @@
+version: '3.8'
+
+services:
+  mongodb:
+    image: mongo:5.0
+    environment:
+      MONGO_INITDB_ROOT_USERNAME: ${MONGO_USER:-mongouser}
+      MONGO_INITDB_ROOT_PASSWORD: ${MONGO_PASSWORD:-mongopassword}
+    volumes:
+      - mongo_data:/data/db
+
+  pyscout-api:
+    build: .
+    depends_on:
+      - mongodb
+    environment:
+      - MONGODB_URI=mongodb://${MONGO_USER:-mongouser}:${MONGO_PASSWORD:-mongopassword}@mongodb:27017/pyscout_ai?authSource=admin
+      - PYSCOUT_MODE=api
+    ports:
+      - "8000:8000"
+
+  gradio-ui:
+    build: .
+    depends_on:
+      - pyscout-api
+    environment:
+      - PYSCOUT_MODE=ui
+      - API_BASE_URL=http://pyscout-api:8000
+    ports:
+      - "7860:7860"
+
+volumes:
+  mongo_data:

docker_entrypoint.py

@@ -0,0 +1,102 @@
+#!/usr/bin/env python3
+"""
+Docker entrypoint script that decides which component to run based on environment variables.
+"""
+import os
+import sys
+import subprocess
+import time
+from pathlib import Path
+
+def run_command(cmd):
+    print(f"Running command: {' '.join(cmd)}")
+    process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
+    
+    # Stream the output
+    for line in process.stdout:
+        sys.stdout.write(line)
+        sys.stdout.flush()
+    
+    process.wait()
+    return process.returncode
+
+def check_required_files():
+    """Check if all required files exist"""
+    required_files = [
+        "pyscout_api.py",
+        "deepinfra_client.py",
+        "proxy_finder.py",
+        "db_helper.py",
+        "hf_utils.py",
+    ]
+    
+    for file in required_files:
+        if not Path(file).exists():
+            print(f"ERROR: Required file '{file}' not found!")
+            return False
+    
+    return True
+
+def wait_for_mongodb():
+    """Wait for MongoDB to be available"""
+    import time
+    import pymongo
+    
+    mongo_uri = os.environ.get("MONGODB_URI")
+    if not mongo_uri:
+        print("MongoDB URI not found in environment variables, skipping connection check")
+        return True
+    
+    max_attempts = 30
+    for attempt in range(max_attempts):
+        try:
+            client = pymongo.MongoClient(mongo_uri, serverSelectionTimeoutMS=5000)
+            client.admin.command('ping')  # Simple command to check connection
+            print(f"MongoDB connection successful after {attempt+1} attempts")
+            return True
+        except Exception as e:
+            print(f"Attempt {attempt+1}/{max_attempts}: MongoDB not yet available. Waiting... ({str(e)})")
+            time.sleep(2)
+    
+    print("ERROR: Failed to connect to MongoDB after multiple attempts")
+    return False
+
+def main():
+    """Main entry point for the Docker container"""
+    if not check_required_files():
+        sys.exit(1)
+    
+    # Determine which component to run based on environment variable
+    mode = os.environ.get("PYSCOUT_MODE", "api").lower()
+    
+    if mode == "api":
+        print("Starting PyScoutAI API server")
+        wait_for_mongodb()
+        cmd = ["python", "pyscout_api.py"]
+        return run_command(cmd)
+        
+    elif mode == "ui":
+        print("Starting Gradio UI")
+        cmd = ["python", "app.py"]
+        return run_command(cmd)
+        
+    elif mode == "all":
+        print("Starting both API server and UI")
+        # Start API server in background
+        api_process = subprocess.Popen(["python", "pyscout_api.py"])
+        time.sleep(5)  # Wait for API to start
+        
+        # Start UI in foreground
+        ui_cmd = ["python", "app.py"]
+        ui_code = run_command(ui_cmd)
+        
+        # Kill API process when UI exits
+        api_process.terminate()
+        return ui_code
+        
+    else:
+        print(f"ERROR: Unknown mode '{mode}'. Valid options: api, ui, all")
+        return 1
+
+if __name__ == "__main__":
+    sys.exit(main())

hf_utils.py

@@ -0,0 +1,106 @@
+import os
+import json
+import requests
+from typing import Dict, Optional, List, Any
+
+class HuggingFaceSpaceHelper:
+    """Helper utilities for integrating with Hugging Face Spaces"""
+    
+    def __init__(self):
+        self.hf_token = os.getenv("HF_TOKEN")
+        self.space_name = os.getenv("HF_SPACE_NAME")
+        self.is_in_space = self._is_huggingface_space()
+    
+    def _is_huggingface_space(self) -> bool:
+        """Check if code is running in a Hugging Face Space"""
+        return os.path.exists("/opt/conda/bin/python") and os.getenv("SPACE_ID") is not None
+    
+    def get_space_url(self) -> str:
+        """Get the URL for the current HF space"""
+        if not self.space_name:
+            return "Not running in a named HF Space"
+        return f"https://huggingface.co/spaces/{self.space_name}"
+    
+    def get_gradio_url(self) -> str:
+        """Get the Gradio URL for the Space"""
+        if not self.space_name:
+            return ""
+        return f"https://{self.space_name}.hf.space"
+    
+    def get_hostname(self) -> str:
+        """Get the appropriate hostname for services in HF Spaces"""
+        if self.is_in_space:
+            # In HF Spaces, services on the same container are accessible via localhost
+            return "localhost" 
+        return "0.0.0.0"  # Default for local development
+    
+    def get_port_mapping(self) -> Dict[int, int]:
+        """Get mappings for ports in HF spaces vs local environment"""
+        # HF Spaces uses specific ports for various services
+        return {
+            7860: 7860,  # Default Gradio port, available publicly
+            8000: 8000,  # FastAPI server, available within container
+            8001: 8001,  # Additional services, available within container
+            # Add more port mappings as needed
+        }
+    
+    def get_hf_metadata(self) -> Dict[str, Any]:
+        """Get metadata about the HF Space environment"""
+        metadata = {
+            "is_huggingface_space": self.is_in_space,
+            "space_name": self.space_name,
+            "space_url": self.get_space_url(),
+            "gradio_url": self.get_gradio_url(),
+        }
+        
+        # Add environment-specific info for HF Spaces
+        if self.is_in_space:
+            metadata.update({
+                "space_id": os.getenv("SPACE_ID"),
+                "space_runtime": os.getenv("SPACE_RUNTIME"),
+                "container_hostname": os.getenv("HOSTNAME"),
+                "python_path": os.getenv("PYTHONPATH"),
+            })
+            
+        return metadata
+    
+    def get_env_file_path(self) -> str:
+        """Get appropriate .env file path based on environment"""
+        if self.is_in_space:
+            return "/app/.env"  # Default location in HF Spaces
+        return ".env"  # Local development
+    
+    def get_mongodb_uri(self) -> Optional[str]:
+        """Get the MongoDB URI, potentially customized for HF Space environment"""
+        # Use environment variable first
+        mongo_uri = os.getenv("MONGODB_URI")
+        
+        # If not available and we're in a Space, try to use HF Spaces secrets
+        if not mongo_uri and self.is_in_space:
+            try:
+                # HF Spaces stores secrets in a specific location
+                from huggingface_hub import get_space_runtime
+                runtime = get_space_runtime()
+                mongo_uri = runtime.get_secret("MONGODB_URI")
+            except:
+                pass
+                
+        return mongo_uri
+        
+    def install_dependencies(self, packages: List[str]):
+        """Install Python packages if needed (useful for HF Spaces)"""
+        if not self.is_in_space:
+            return  # Skip in local environments
+            
+        import subprocess
+        try:
+            subprocess.check_call(["pip", "install", "--no-cache-dir"] + packages)
+            print(f"Successfully installed: {', '.join(packages)}")
+        except subprocess.CalledProcessError as e:
+            print(f"Failed to install packages: {e}")
+
+if __name__ == "__main__":
+    hf_helper = HuggingFaceSpaceHelper()
+    print(json.dumps(hf_helper.get_hf_metadata(), indent=2))
+    print(f"MongoDB URI: {hf_helper.get_mongodb_uri() or 'Not configured'}")
+    print(f"Environment file path: {hf_helper.get_env_file_path()}")

proxy_finder.py

@@ -0,0 +1,290 @@
+import json
+import datetime
+import requests
+import re
+import random
+import time
+from concurrent.futures import ThreadPoolExecutor
+from typing import Dict, List, Optional, Set, Tuple, Union
+
+class ProxyFinder:
+    """Finds and validates proxies from various online sources"""
+    
+    def __init__(self, verbose: bool = False):
+        """Initialize ProxyFinder with optional verbose logging"""
+        self.verbose = verbose
+        self.api: Dict[str, List[str]] = {
+            'socks4': [
+                "https://api.proxyscrape.com/?request=displayproxies&proxytype=socks4&timeout=10000&country=all&simplified=true",
+                "https://www.proxy-list.download/api/v1/get?type=socks4",
+                "https://api.openproxylist.xyz/socks4.txt",
+                'https://openproxy.space/list/socks4',
+                'https://proxyspace.pro/socks4.txt',
+                "https://sunny9577.github.io/proxy-scraper/generated/socks4_proxies.txt",
+                'https://cdn.rei.my.id/proxy/SOCKS4',
+                "https://raw.githubusercontent.com/TheSpeedX/PROXY-List/master/socks4.txt", 
+                "https://raw.githubusercontent.com/roosterkid/openproxylist/main/SOCKS4_RAW.txt",
+                'https://raw.githubusercontent.com/monosans/proxy-list/main/proxies/socks4.txt'
+            ],
+            'socks5': [
+                "https://api.proxyscrape.com/v2/?request=getproxies&protocol=socks5&timeout=10000&country=all&simplified=true",
+                "https://www.proxy-list.download/api/v1/get?type=socks5",
+                "https://api.openproxylist.xyz/socks5.txt",
+                'https://openproxy.space/list/socks5',
+                'https://spys.me/socks.txt',
+                'https://proxyspace.pro/socks5.txt',
+                "https://sunny9577.github.io/proxy-scraper/generated/socks5_proxies.txt",
+                'https://cdn.rei.my.id/proxy/SOCKS5',
+                'https://raw.githubusercontent.com/manuGMG/proxy-365/main/SOCKS5.txt',
+                "https://raw.githubusercontent.com/TheSpeedX/PROXY-List/master/socks5.txt",
+                "https://raw.githubusercontent.com/hookzof/socks5_list/master/proxy.txt"
+            ],
+            'http': [
+                'https://raw.githubusercontent.com/officialputuid/KangProxy/KangProxy/http/http.txt',
+                "https://github.com/TheSpeedX/PROXY-List/raw/refs/heads/master/http.txt",
+                "https://api.proxyscrape.com/?request=displayproxies&proxytype=http&timeout=10000&country=all&simplified=true",
+                "https://www.proxy-list.download/api/v1/get?type=http",
+                "https://api.openproxylist.xyz/http.txt",
+                'https://openproxy.space/list/http',
+                'https://proxyspace.pro/http.txt',
+                "https://sunny9577.github.io/proxy-scraper/generated/http_proxies.txt",
+                'https://cdn.rei.my.id/proxy/HTTP',
+                'https://raw.githubusercontent.com/UptimerBot/proxy-list/master/proxies/http.txt',
+                'https://raw.githubusercontent.com/TheSpeedX/SOCKS-List/master/http.txt'
+            ],
+            'https': [
+                'https://raw.githubusercontent.com/Firdoxx/proxy-list/main/https',
+                'https://raw.githubusercontent.com/roosterkid/openproxylist/main/HTTPS_RAW.txt',
+                'https://raw.githubusercontent.com/aslisk/proxyhttps/main/https.txt',
+                'https://raw.githubusercontent.com/ErcinDedeoglu/proxies/main/proxies/https.txt',
+                'https://raw.githubusercontent.com/zloi-user/hideip.me/main/https.txt',
+                'https://raw.githubusercontent.com/vakhov/fresh-proxy-list/master/https.txt',
+                'https://raw.githubusercontent.com/Vann-Dev/proxy-list/main/proxies/https.txt'
+            ],
+            'mixed': [
+                'https://github.com/jetkai/proxy-list/blob/main/online-proxies/txt/proxies.txt',
+                'https://raw.githubusercontent.com/mertguvencli/http-proxy-list/main/proxy-list/data.txt',
+                'https://raw.githubusercontent.com/a2u/free-proxy-list/master/free-proxy-list.txt',
+                'https://raw.githubusercontent.com/mishakorzik/Free-Proxy/main/proxy.txt',
+                'http://rootjazz.com/proxies/proxies.txt',
+                'https://multiproxy.org/txt_all/proxy.txt',
+                'https://proxy-spider.com/api/proxies.example.txt'
+            ]
+        }
+        self.proxy_dict: Dict[str, List[str]] = {'socks4': [], 'socks5': [], 'http': [], 'https': []}
+        self.max_workers = 20  # Maximum workers for parallel requests
+    
+    def log(self, *args):
+        """Log messages if verbose mode is enabled"""
+        if self.verbose:
+            print(*args)
+            
+    def extract_proxy(self, line: str) -> Optional[str]:
+        """
+        Extracts the first occurrence of an IP:port from a line.
+        """
+        match = re.search(r'(\d{1,3}(?:\.\d{1,3}){3}:\d{2,5})', line)
+        if match:
+            return match.group(1)
+        return None
+
+    def fetch_from_url(self, url: str, proxy_type: str) -> List[str]:
+        """
+        Fetches proxies from a given URL for the specified type.
+        Returns a list of valid proxies.
+        """
+        proxy_list = []
+        try:
+            r = requests.get(url, timeout=5)
+            if r.status_code == requests.codes.ok:
+                for line in r.text.splitlines():
+                    proxy = self.extract_proxy(line)
+                    if proxy:
+                        proxy_list.append(proxy)
+                self.log(f"Got {len(proxy_list)} {proxy_type} proxies from {url}")
+            return proxy_list
+        except Exception as e:
+            self.log(f"Failed to retrieve from {url}: {str(e)}")
+            return []
+
+    def fetch_proxies_parallel(self, proxy_type: str) -> List[str]:
+        """
+        Fetch proxies in parallel for a specific type from all sources.
+        """
+        if proxy_type not in self.api:
+            return []
+            
+        all_proxies = []
+        with ThreadPoolExecutor(max_workers=self.max_workers) as executor:
+            futures = [executor.submit(self.fetch_from_url, url, proxy_type) 
+                      for url in self.api[proxy_type]]
+            for future in futures:
+                all_proxies.extend(future.result())
+                
+        return list(set(all_proxies))  # Remove duplicates
+
+    def get_geonode_proxies(self) -> Dict[str, List[str]]:
+        """
+        Retrieves proxies from geonode API
+        """
+        result = {'http': [], 'socks4': [], 'socks5': [], 'https': []}
+        try:
+            url = 'https://proxylist.geonode.com/api/proxy-list?limit=500&sort_by=lastChecked&sort_type=desc'
+            response = requests.get(url, timeout=10)
+            
+            if response.status_code == 200:
+                data = response.json()
+                for p in data.get('data', []):
+                    for protocol in p.get('protocols', []):
+                        protocol = protocol.lower()
+                        # Map 'https' to 'http' in our dictionary
+                        if protocol == 'https':
+                            result['http'].append(f"{p['ip']}:{p['port']}")
+                        elif protocol in result:
+                            result[protocol].append(f"{p['ip']}:{p['port']}")
+                
+                self.log(f"Got {sum(len(v) for v in result.values())} proxies from GeoNode")
+        except Exception as e:
+            self.log(f"Failed to fetch from GeoNode: {str(e)}")
+        
+        return result
+
+    def get_checkerproxy_archive(self) -> Dict[str, List[str]]:
+        """
+        Gets proxies from checkerproxy.net archive
+        """
+        result = {'http': [], 'socks5': []}
+        
+        for q in range(5):  # Check only last 5 days to be faster
+            day = datetime.date.today() + datetime.timedelta(days=-q)
+            formatted_date = f'{day.year}-{day.month}-{day.day}'
+            
+            try:
+                r = requests.get(f'https://checkerproxy.net/api/archive/{formatted_date}', timeout=5)
+                if r.text != '[]':
+                    json_result = json.loads(r.text)
+                    for i in json_result:
+                        # Skip internal IPs
+                        if re.match(r"172\.|192\.168\.|10\.", i['ip']):
+                            continue
+                            
+                        addr = i.get('addr')
+                        if not addr:
+                            continue
+                            
+                        if i['type'] in [1, 2]:
+                            result['http'].append(addr)
+                        if i['type'] == 4:
+                            result['socks5'].append(addr)
+                    
+                    self.log(f"Got {len(result['http'])} http and {len(result['socks5'])} socks5 proxies from CheckerProxy for {formatted_date}")
+            except Exception as e:
+                self.log(f"Failed to get archive for {formatted_date}: {str(e)}")
+                
+        return result
+
+    def get_proxies(self, proxy_types: List[str] = None) -> Dict[str, List[str]]:
+        """
+        Get proxies of the specified types. If None, get all types.
+        Returns a dictionary with proxy lists for each type.
+        """
+        if proxy_types is None:
+            proxy_types = ['http', 'https', 'socks4', 'socks5']
+            
+        # Reset proxy dictionary
+        self.proxy_dict = {'socks4': [], 'socks5': [], 'http': [], 'https': []}
+        
+        self.log("Starting proxy retrieval process")
+        
+        # Fetch from regular sources in parallel for each type
+        for ptype in proxy_types:
+            if ptype in self.api:
+                self.log(f"Processing {ptype} proxy sources")
+                proxies = self.fetch_proxies_parallel(ptype)
+                self.proxy_dict[ptype].extend(proxies)
+        
+        # Add proxies from GeoNode
+        geonode_proxies = self.get_geonode_proxies()
+        for ptype, proxies in geonode_proxies.items():
+            if ptype in proxy_types:
+                self.proxy_dict[ptype].extend(proxies)
+        
+        # Add proxies from CheckerProxy
+        checker_proxies = self.get_checkerproxy_archive()
+        for ptype, proxies in checker_proxies.items():
+            if ptype in proxy_types:
+                self.proxy_dict[ptype].extend(proxies)
+                
+        # Process "mixed" sources if any proxy type is requested
+        if proxy_types:
+            self.log("Processing mixed proxy sources")
+            for url in self.api.get('mixed', []):
+                try:
+                    proxies = self.fetch_from_url(url, 'mixed')
+                    # Distribute mixed proxies equally among requested types
+                    if proxies:
+                        chunks = len(proxy_types)
+                        chunk_size = len(proxies) // chunks if chunks > 0 else 0
+                        for i, ptype in enumerate(proxy_types):
+                            start = i * chunk_size
+                            end = start + chunk_size if i < chunks - 1 else len(proxies)
+                            self.proxy_dict[ptype].extend(proxies[start:end])
+                except Exception as e:
+                    self.log(f"Failed to process mixed proxy source: {str(e)}")
+        
+        # Remove duplicates for all types
+        for key in self.proxy_dict:
+            original_count = len(self.proxy_dict[key])
+            self.proxy_dict[key] = list(set(self.proxy_dict[key]))
+            new_count = len(self.proxy_dict[key])
+            self.log(f"Removed {original_count - new_count} duplicate {key} proxies")
+            
+        self.log("Proxy retrieval process completed")
+        return self.proxy_dict
+
+    def get_random_proxy(self, proxy_type: str = None) -> Optional[str]:
+        """
+        Returns a random proxy of the specified type.
+        If type is None, returns a random proxy from any type.
+        """
+        if proxy_type and proxy_type in self.proxy_dict and self.proxy_dict[proxy_type]:
+            return random.choice(self.proxy_dict[proxy_type])
+        elif not proxy_type:
+            # Combine all proxy types and get a random one
+            all_proxies = []
+            for ptype in self.proxy_dict:
+                all_proxies.extend(self.proxy_dict[ptype])
+            if all_proxies:
+                return random.choice(all_proxies)
+        return None
+        
+    def get_random_proxies(self, count: int = 10, proxy_type: str = None) -> List[str]:
+        """
+        Returns a list of random proxies of the specified type.
+        If type is None, returns random proxies from any type.
+        """
+        if proxy_type and proxy_type in self.proxy_dict:
+            proxies = self.proxy_dict[proxy_type]
+        else:
+            # Combine all proxy types
+            proxies = []
+            for ptype in self.proxy_dict:
+                proxies.extend(self.proxy_dict[ptype])
+                
+        # Get random proxies up to count or as many as available
+        if not proxies:
+            return []
+            
+        return random.sample(proxies, min(count, len(proxies)))
+
+if __name__ == "__main__":
+    # Example usage
+    finder = ProxyFinder(verbose=True)
+    proxies = finder.get_proxies(['http', 'socks5'])
+    
+    print("\nSummary:")
+    for ptype, proxy_list in proxies.items():
+        print(f"{ptype}: {len(proxy_list)} proxies")
+    
+    print("\nRandom HTTP proxy:", finder.get_random_proxy('http'))
+    print("\nRandom SOCKS5 proxies:", finder.get_random_proxies(5, 'socks5'))

pyscout_api.py

@@ -0,0 +1,438 @@
+import asyncio
+import time
+import uuid
+import os
+import json
+from typing import Dict, List, Optional, Union, Any
+from fastapi import FastAPI, HTTPException, Depends, Request, status, Body
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse, StreamingResponse
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from pydantic import BaseModel, Field, EmailStr
+from slowapi import Limiter, _rate_limit_exceeded_handler
+from slowapi.util import get_remote_address
+from slowapi.errors import RateLimitExceeded
+import uvicorn
+
+from db_helper import MongoDBHelper
+from deepinfra_client import DeepInfraClient
+from hf_utils import HuggingFaceSpaceHelper
+
+# Initialize Hugging Face Space helper
+hf_helper = HuggingFaceSpaceHelper()
+
+# Install required packages for HF Spaces if needed
+if hf_helper.is_in_space:
+    hf_helper.install_dependencies([
+        "pymongo", "python-dotenv", "fastapi", "uvicorn", "slowapi",
+        "fake-useragent", "requests-ip-rotator", "pydantic[email]"
+    ])
+
+# Initialize FastAPI app
+app = FastAPI(
+    title="PyScoutAI API",
+    description="An OpenAI-compatible API that provides access to DeepInfra models with enhanced features",
+    version="1.0.0"
+)
+
+# Setup rate limiting
+limiter = Limiter(key_func=get_remote_address)
+app.state.limiter = limiter
+app.add_exception_handler(RateLimitExceeded, _rate_limit_exceeded_handler)
+
+# Set up CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Security
+security = HTTPBearer(auto_error=False)
+
+# Database helper
+try:
+    db = MongoDBHelper(hf_helper.get_mongodb_uri())
+except Exception as e:
+    print(f"Warning: MongoDB connection failed: {e}")
+    print("API key authentication will not work!")
+    db = None
+
+# Models for requests and responses
+class Message(BaseModel):
+    role: str
+    content: Optional[str] = None
+    name: Optional[str] = None
+
+class ChatCompletionRequest(BaseModel):
+    model: str
+    messages: List[Message]
+    temperature: Optional[float] = 0.7
+    top_p: Optional[float] = 1.0
+    n: Optional[int] = 1
+    stream: Optional[bool] = False
+    max_tokens: Optional[int] = None
+    presence_penalty: Optional[float] = 0.0
+    frequency_penalty: Optional[float] = 0.0
+    user: Optional[str] = None
+
+class CompletionRequest(BaseModel):
+    model: str
+    prompt: Union[str, List[str]]
+    temperature: Optional[float] = 0.7
+    top_p: Optional[float] = 1.0
+    n: Optional[int] = 1
+    stream: Optional[bool] = False
+    max_tokens: Optional[int] = None
+    presence_penalty: Optional[float] = 0.0
+    frequency_penalty: Optional[float] = 0.0
+    user: Optional[str] = None
+
+class UserCreate(BaseModel):
+    email: EmailStr
+    name: str
+    organization: Optional[str] = None
+
+class APIKeyCreate(BaseModel):
+    name: str = "Default API Key"
+    user_id: str
+
+class APIKeyResponse(BaseModel):
+    key: str
+    name: str
+    created_at: str
+
+# API clients storage (one per API key)
+clients: Dict[str, DeepInfraClient] = {}
+
+# Helper function to get the API key from the request
+async def get_api_key(
+    request: Request,
+    credentials: Optional[HTTPAuthorizationCredentials] = Depends(security)
+) -> Optional[str]:
+    # Check Authorization header
+    if credentials:
+        return credentials.credentials
+    
+    # Check for API key in the request headers
+    if "Authorization" in request.headers:
+        auth = request.headers["Authorization"]
+        if auth.startswith("Bearer "):
+            return auth.replace("Bearer ", "")
+    
+    if "x-api-key" in request.headers:
+        return request.headers["x-api-key"]
+    
+    # Check for API key in query parameters
+    api_key = request.query_params.get("api_key")
+    if api_key:
+        return api_key
+    
+    # No API key found, return None
+    return None
+
+# Helper function to validate a PyScout API key and get user info
+async def get_user_info(api_key: Optional[str] = Depends(get_api_key)) -> Dict[str, Any]:
+    if not api_key:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="API key is required",
+            headers={"WWW-Authenticate": "Bearer"}
+        )
+    
+    # Skip validation if DB is not connected (development mode)
+    if not db:
+        return {"user_id": "development", "key": api_key}
+    
+    # Check if key starts with PyScoutAI-
+    if not api_key.startswith("PyScoutAI-"):
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid API key format",
+            headers={"WWW-Authenticate": "Bearer"}
+        )
+    
+    # Validate the API key
+    user_info = db.validate_api_key(api_key)
+    if not user_info:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid API key",
+            headers={"WWW-Authenticate": "Bearer"}
+        )
+    
+    # Check rate limits
+    rate_limit = db.check_rate_limit(api_key)
+    if not rate_limit["allowed"]:
+        raise HTTPException(
+            status_code=status.HTTP_429_TOO_MANY_REQUESTS,
+            detail=rate_limit["reason"]
+        )
+    
+    return user_info
+
+# Helper function to get or create a client
+def get_client(api_key: str) -> DeepInfraClient:
+    if api_key not in clients:
+        # Create a client with IP rotation and random user agent
+        clients[api_key] = DeepInfraClient(
+            use_random_user_agent=True,
+            use_proxy_rotation=True,
+            use_ip_rotation=True
+        )
+    return clients[api_key]
+
+@app.get("/")
+async def root():
+    metadata = hf_helper.get_hf_metadata()
+    return {
+        "message": "Welcome to PyScoutAI API",
+        "documentation": "/docs",
+        "environment": "Hugging Face Space" if hf_helper.is_in_space else "Local",
+        "endpoints": [
+            "/v1/models",
+            "/v1/chat/completions",
+            "/v1/completions"
+        ],
+        **metadata
+    }
+
+@app.get("/v1/models")
+@limiter.limit("20/minute")
+async def list_models(
+    request: Request, 
+    user_info: Dict[str, Any] = Depends(get_user_info)
+):
+    api_key = user_info["key"]
+    client = get_client(api_key)
+    try:
+        models = await asyncio.to_thread(client.models.list)
+        # Log the API usage
+        if db:
+            db.log_api_usage(api_key, "/v1/models", 0)
+        return models
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error listing models: {str(e)}")
+
+@app.post("/v1/chat/completions")
+@limiter.limit("60/minute")
+async def create_chat_completion(
+    request: Request,
+    body: ChatCompletionRequest,
+    user_info: Dict[str, Any] = Depends(get_user_info)
+):
+    api_key = user_info["key"]
+    client = get_client(api_key)
+    
+    try:
+        # Prepare the messages
+        messages = [{"role": msg.role, "content": msg.content} for msg in body.messages if msg.content is not None]
+        
+        kwargs = {
+            "model": body.model,
+            "temperature": body.temperature,
+            "max_tokens": body.max_tokens,
+            "stream": body.stream,
+            "top_p": body.top_p,
+            "presence_penalty": body.presence_penalty,
+            "frequency_penalty": body.frequency_penalty,
+        }
+                
+        if body.stream:
+            async def generate_stream():
+                response_stream = await asyncio.to_thread(
+                    client.chat.create,
+                    messages=messages,
+                    **kwargs
+                )
+                
+                total_tokens = 0
+                for chunk in response_stream:
+                    # Track token usage for each chunk if available
+                    if 'usage' in chunk and chunk['usage']:
+                        total_tokens += chunk['usage'].get('total_tokens', 0)
+                    
+                    yield f"data: {json.dumps(chunk)}\n\n"
+                
+                # Log API usage at the end of streaming
+                if db:
+                    db.log_api_usage(api_key, "/v1/chat/completions", total_tokens, body.model)
+                    
+                yield "data: [DONE]\n\n"
+                
+            return StreamingResponse(
+                generate_stream(),
+                media_type="text/event-stream"
+            )
+        else:
+            response = await asyncio.to_thread(
+                client.chat.create,
+                messages=messages,
+                **kwargs
+            )
+            
+            # Log the API usage
+            if db and 'usage' in response:
+                total_tokens = response['usage'].get('total_tokens', 0)
+                db.log_api_usage(api_key, "/v1/chat/completions", total_tokens, body.model)
+                
+            return response
+            
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error generating chat completion: {str(e)}")
+
+@app.post("/v1/completions")
+@limiter.limit("60/minute")
+async def create_completion(
+    request: Request,
+    body: CompletionRequest,
+    user_info: Dict[str, Any] = Depends(get_user_info)
+):
+    api_key = user_info["key"]
+    client = get_client(api_key)
+    
+    try:
+        # Handle different prompt types
+        prompt = body.prompt
+        if isinstance(prompt, list):
+            prompt = prompt[0]  # Take the first prompt if it's a list
+            
+        kwargs = {
+            "model": body.model,
+            "temperature": body.temperature,
+            "max_tokens": body.max_tokens,
+            "stream": body.stream,
+            "top_p": body.top_p,
+            "presence_penalty": body.presence_penalty,
+            "frequency_penalty": body.frequency_penalty,
+        }
+            
+        if body.stream:
+            async def generate_stream():
+                response_stream = await asyncio.to_thread(
+                    client.completions.create,
+                    prompt=prompt,
+                    **kwargs
+                )
+                
+                total_tokens = 0
+                for chunk in response_stream:
+                    if 'usage' in chunk and chunk['usage']:
+                        total_tokens += chunk['usage'].get('total_tokens', 0)
+                    
+                    yield f"data: {json.dumps(chunk)}\n\n"
+                
+                # Log API usage at the end of streaming
+                if db:
+                    db.log_api_usage(api_key, "/v1/completions", total_tokens, body.model)
+                    
+                yield "data: [DONE]\n\n"
+                
+            return StreamingResponse(
+                generate_stream(),
+                media_type="text/event-stream"
+            )
+        else:
+            response = await asyncio.to_thread(
+                client.completions.create,
+                prompt=prompt,
+                **kwargs
+            )
+            
+            # Log the API usage
+            if db and 'usage' in response:
+                total_tokens = response['usage'].get('total_tokens', 0)
+                db.log_api_usage(api_key, "/v1/completions", total_tokens, body.model)
+                
+            return response
+            
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error generating completion: {str(e)}")
+
+@app.get("/health")
+async def health_check():
+    status_info = {"api": "ok"}
+    
+    # Check MongoDB connection
+    if db:
+        try:
+            # Simple operation to check connection
+            db.api_keys_collection.find_one({})
+            status_info["database"] = "ok"
+        except Exception as e:
+            status_info["database"] = f"error: {str(e)}"
+    else:
+        status_info["database"] = "not configured"
+    
+    # Add Hugging Face Space info
+    if hf_helper.is_in_space:
+        status_info["environment"] = "Hugging Face Space"
+        status_info["space_name"] = hf_helper.space_name
+    else:
+        status_info["environment"] = "Local"
+    
+    return status_info
+
+# API Key Management Endpoints
+@app.post("/v1/api_keys", response_model=APIKeyResponse)
+async def create_api_key(body: APIKeyCreate):
+    if not db:
+        raise HTTPException(status_code=500, detail="Database not configured")
+    
+    try:
+        api_key = db.generate_api_key(body.user_id, body.name)
+        key_data = db.validate_api_key(api_key)
+        return {
+            "key": api_key,
+            "name": key_data["name"],
+            "created_at": key_data["created_at"].isoformat()
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error creating API key: {str(e)}")
+
+@app.get("/v1/api_keys")
+async def list_api_keys(user_id: str):
+    if not db:
+        raise HTTPException(status_code=500, detail="Database not configured")
+    
+    keys = db.get_user_api_keys(user_id)
+    for key in keys:
+        if "created_at" in key:
+            key["created_at"] = key["created_at"].isoformat()
+        if "last_used" in key and key["last_used"]:
+            key["last_used"] = key["last_used"].isoformat()
+    
+    return {"keys": keys}
+
+@app.post("/v1/api_keys/revoke")
+async def revoke_api_key(api_key: str):
+    if not db:
+        raise HTTPException(status_code=500, detail="Database not configured")
+    
+    success = db.revoke_api_key(api_key)
+    if not success:
+        raise HTTPException(status_code=404, detail="API key not found")
+    
+    return {"message": "API key revoked successfully"}
+
+# Clean up IP rotator clients on shutdown
+@app.on_event("shutdown")
+async def cleanup_clients():
+    for client in clients.values():
+        try:
+            if hasattr(client, 'ip_rotator') and client.ip_rotator:
+                client.ip_rotator.shutdown()
+        except:
+            pass
+
+if __name__ == "__main__":
+    # Get host and port based on environment
+    host = hf_helper.get_hostname()
+    port = 8000  # Default port for FastAPI
+    
+    print(f"Starting PyScoutAI API on http://{host}:{port}")
+    print(f"Environment: {'Hugging Face Space' if hf_helper.is_in_space else 'Local'}")
+    
+    uvicorn.run("pyscout_api:app", host=host, port=port, reload=not hf_helper.is_in_space)

requirements.txt

@@ -0,0 +1,9 @@
+fastapi==0.104.1
+uvicorn==0.24.0
+pydantic==2.4.2
+requests==2.31.0
+slowapi==0.1.8
+python-dotenv==1.0.0
+rich==13.6.0
+fake-useragent==1.2.1
+requests-ip-rotator==1.0.14

run_api_server.py

@@ -0,0 +1,46 @@
+import os
+import uvicorn
+import argparse
+from rich.console import Console
+from rich.panel import Panel
+from dotenv import load_dotenv
+
+# Load environment variables from .env file if present
+load_dotenv()
+
+console = Console()
+
+def main():
+    parser = argparse.ArgumentParser(description='Run the OpenAI-compatible API server for DeepInfra')
+    parser.add_argument('--host', default='0.0.0.0', help='Host to bind the server to')
+    parser.add_argument('--port', type=int, default=8000, help='Port to bind the server to')
+    parser.add_argument('--reload', action='store_true', help='Enable auto-reload for development')
+    
+    args = parser.parse_args()
+    
+    console.print(Panel.fit(
+        "[bold green]DeepInfra OpenAI-Compatible API Server[/bold green]\n"
+        f"Starting server on http://{args.host}:{args.port}\n"
+        "Press Ctrl+C to stop the server.",
+        title="Server Info",
+        border_style="blue"
+    ))
+    
+    # Additional info on endpoints
+    console.print("[bold cyan]Available endpoints:[/bold cyan]")
+    console.print("- [yellow]/v1/models[/yellow] - List available models")
+    console.print("- [yellow]/v1/chat/completions[/yellow] - Chat completions endpoint")
+    console.print("- [yellow]/v1/completions[/yellow] - Text completions endpoint")
+    console.print("- [yellow]/health[/yellow] - Health check endpoint")
+    console.print("\nAPI documentation available at [link]http://localhost:8000/docs[/link]")
+    
+    # Run the server
+    uvicorn.run(
+        "openai_compatible_api:app", 
+        host=args.host, 
+        port=args.port, 
+        reload=args.reload
+    )
+
+if __name__ == "__main__":
+    main()