webscout 8.3.1__py3-none-any.whl → 8.3.3__py3-none-any.whl

webscout/auth/__init__.py

@@ -0,0 +1,55 @@
+# webscout/auth/__init__.py
+
+from .models import User, APIKey
+from .database import DatabaseManager
+from .api_key_manager import APIKeyManager
+from .rate_limiter import RateLimiter
+from .middleware import AuthMiddleware
+from .schemas import (
+    APIKeyCreateRequest,
+    APIKeyCreateResponse,
+    APIKeyValidationResponse,
+    UserCreateRequest,
+    UserResponse,
+    HealthCheckResponse
+)
+# Import server functions lazily to avoid module execution issues
+def create_app():
+    from .server import create_app as _create_app
+    return _create_app()
+
+def run_api(*args, **kwargs):
+    from .server import run_api as _run_api
+    return _run_api(*args, **kwargs)
+
+def start_server(*args, **kwargs):
+    from .server import start_server as _start_server
+    return _start_server(*args, **kwargs)
+from .routes import Api
+from .config import ServerConfig, AppConfig
+from .exceptions import APIError
+from .providers import initialize_provider_map, initialize_tti_provider_map
+
+__all__ = [
+    "User",
+    "APIKey",
+    "DatabaseManager",
+    "APIKeyManager",
+    "RateLimiter",
+    "AuthMiddleware",
+    "APIKeyCreateRequest",
+    "APIKeyCreateResponse",
+    "APIKeyValidationResponse",
+    "UserCreateRequest",
+    "UserResponse",
+    "HealthCheckResponse",
+    "create_app",
+    "run_api",
+    "start_server",
+    "Api",
+    "ServerConfig",
+    "AppConfig",
+    "APIError",
+    "initialize_provider_map",
+    "initialize_tti_provider_map"
+]

webscout/auth/api_key_manager.py

@@ -0,0 +1,189 @@
+# webscout/auth/api_key_manager.py
+
+import secrets
+import string
+from datetime import datetime, timezone, timedelta
+from typing import Optional, Tuple
+import hashlib
+import logging
+
+from .models import User, APIKey
+from .database import DatabaseManager
+
+logger = logging.getLogger(__name__)
+
+
+class APIKeyManager:
+    """Manages API key generation, validation, and lifecycle."""
+    
+    def __init__(self, database_manager: DatabaseManager):
+        self.db = database_manager
+        self.key_prefix = "ws_"  # webscout prefix
+        self.key_length = 32  # Length of the random part
+    
+    def generate_api_key(self) -> str:
+        """Generate a secure API key."""
+        # Generate random string
+        alphabet = string.ascii_letters + string.digits
+        random_part = ''.join(secrets.choice(alphabet) for _ in range(self.key_length))
+        
+        # Add prefix
+        api_key = f"{self.key_prefix}{random_part}"
+        
+        return api_key
+    
+    def hash_api_key(self, api_key: str) -> str:
+        """Hash an API key for secure storage (optional, for extra security)."""
+        return hashlib.sha256(api_key.encode()).hexdigest()
+    
+    async def create_api_key(
+        self,
+        username: str,
+        telegram_id: str,
+        name: Optional[str] = None,
+        rate_limit: int = 10,
+        expires_in_days: Optional[int] = None
+    ) -> Tuple[APIKey, User]:
+        """Create a new API key and associated user if needed. Only one API key per user allowed."""
+
+        # Check if user already exists by telegram_id
+        user = await self.db.get_user_by_telegram_id(telegram_id)
+
+        if user:
+            # Check if user already has an API key
+            existing_keys = await self.db.get_api_keys_by_user(user.id)
+            active_keys = [key for key in existing_keys if key.is_active and not key.is_expired()]
+
+            if active_keys:
+                raise ValueError(f"User with Telegram ID {telegram_id} already has an active API key. Only one API key per user is allowed.")
+        else:
+            # Check if username is already taken
+            existing_user = await self.db.get_user_by_username(username)
+            if existing_user:
+                raise ValueError(f"Username '{username}' is already taken")
+
+            # Create new user
+            user = User(
+                username=username,
+                telegram_id=telegram_id,
+                created_at=datetime.now(timezone.utc),
+                updated_at=datetime.now(timezone.utc)
+            )
+            try:
+                user = await self.db.create_user(user)
+                logger.info(f"Created new user: {user.username} (Telegram ID: {telegram_id})")
+            except ValueError as e:
+                # User might already exist, try to get it
+                if "already exists" in str(e):
+                    user = await self.db.get_user_by_telegram_id(telegram_id)
+                    if not user:
+                        raise e
+                else:
+                    raise e
+        
+        # Generate API key
+        api_key_value = self.generate_api_key()
+        
+        # Calculate expiration
+        expires_at = None
+        if expires_in_days:
+            expires_at = datetime.now(timezone.utc) + timedelta(days=expires_in_days)
+        
+        # Create API key object
+        api_key = APIKey(
+            key=api_key_value,
+            user_id=user.id,
+            name=name,
+            created_at=datetime.now(timezone.utc),
+            expires_at=expires_at,
+            rate_limit=rate_limit,
+            is_active=True
+        )
+        
+        # Store in database
+        try:
+            api_key = await self.db.create_api_key(api_key)
+            logger.info(f"Created API key for user {user.username}: {api_key.id}")
+            return api_key, user
+        except ValueError as e:
+            # Key collision (very unlikely), try again
+            if "already exists" in str(e):
+                logger.warning("API key collision detected, regenerating...")
+                return await self.create_api_key(username, telegram_id, name, rate_limit, expires_in_days)
+            raise e
+    
+    async def validate_api_key(self, api_key: str) -> Tuple[bool, Optional[APIKey], Optional[str]]:
+        """
+        Validate an API key.
+        
+        Returns:
+            Tuple of (is_valid, api_key_object, error_message)
+        """
+        if not api_key:
+            return False, None, "API key is required"
+        
+        if not api_key.startswith(self.key_prefix):
+            return False, None, "Invalid API key format"
+        
+        try:
+            # Get API key from database
+            key_obj = await self.db.get_api_key(api_key)
+            
+            if not key_obj:
+                return False, None, "API key not found"
+            
+            if not key_obj.is_active:
+                return False, None, "API key is inactive"
+            
+            if key_obj.is_expired():
+                return False, None, "API key has expired"
+            
+            # Update last used timestamp
+            key_obj.last_used_at = datetime.now(timezone.utc)
+            key_obj.usage_count += 1
+            
+            try:
+                await self.db.update_api_key(key_obj)
+            except Exception as e:
+                logger.warning(f"Failed to update API key usage: {e}")
+            
+            return True, key_obj, None
+            
+        except Exception as e:
+            logger.error(f"Error validating API key: {e}")
+            return False, None, "Internal error during validation"
+    
+    async def revoke_api_key(self, api_key: str) -> bool:
+        """Revoke an API key by marking it as inactive."""
+        try:
+            key_obj = await self.db.get_api_key(api_key)
+            
+            if not key_obj:
+                return False
+            
+            key_obj.is_active = False
+            key_obj.updated_at = datetime.now(timezone.utc)
+            
+            await self.db.update_api_key(key_obj)
+            logger.info(f"Revoked API key: {key_obj.id}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Error revoking API key: {e}")
+            return False
+    
+    async def get_user_api_keys(self, user_id: str) -> list[APIKey]:
+        """Get all API keys for a user."""
+        try:
+            return await self.db.get_api_keys_by_user(user_id)
+        except Exception as e:
+            logger.error(f"Error getting user API keys: {e}")
+            return []
+    
+    async def cleanup_expired_keys(self) -> int:
+        """Clean up expired API keys (mark as inactive)."""
+        # This would require a method to get all API keys, which we haven't implemented
+        # For now, we'll just return 0
+        # In a production system, you'd want to implement this properly
+        logger.info("Cleanup expired keys called (not implemented)")
+        return 0

webscout/auth/auth_system.py

@@ -0,0 +1,100 @@
+"""
+Authentication system initialization for the Webscout API.
+"""
+
+import os
+import sys
+from typing import Optional
+from fastapi import FastAPI
+
+from webscout.Litlogger import Logger, LogLevel, LogFormat, ConsoleHandler
+from .database import DatabaseManager
+from .api_key_manager import APIKeyManager
+from .rate_limiter import RateLimiter
+from .middleware import AuthMiddleware
+
+# Setup logger
+logger = Logger(
+    name="webscout.api",
+    level=LogLevel.INFO,
+    handlers=[ConsoleHandler(stream=sys.stdout)],
+    fmt=LogFormat.DEFAULT
+)
+
+# Global authentication system instances
+db_manager: Optional[DatabaseManager] = None
+api_key_manager: Optional[APIKeyManager] = None
+rate_limiter: Optional[RateLimiter] = None
+auth_middleware: Optional[AuthMiddleware] = None
+
+
+def initialize_auth_system(app: FastAPI, auth_required: bool = True, rate_limit_enabled: bool = True) -> None:
+    """Initialize the authentication system."""
+    global db_manager, api_key_manager, rate_limiter, auth_middleware
+
+    if not auth_required:
+        logger.info("Auth system is disabled (no-auth mode): skipping DB and API key manager initialization.")
+        db_manager = None
+        api_key_manager = None
+        rate_limiter = None
+        auth_middleware = None
+        return
+
+    try:
+        # Initialize database manager
+        mongo_url = os.getenv("MONGODB_URL")
+        data_dir = os.getenv("WEBSCOUT_DATA_DIR", "data")
+
+        db_manager = DatabaseManager(mongo_url, data_dir)
+
+        # Initialize API key manager
+        api_key_manager = APIKeyManager(db_manager)
+
+        # Initialize rate limiter
+        rate_limiter = RateLimiter(db_manager)
+
+        # Initialize auth middleware with configuration
+        auth_middleware = AuthMiddleware(
+            api_key_manager,
+            rate_limiter,
+            auth_required=auth_required,
+            rate_limit_enabled=rate_limit_enabled
+        )
+
+        # Add auth middleware to app
+        app.middleware("http")(auth_middleware)
+
+        # Add startup event to initialize database
+        async def startup_event():
+            if db_manager:
+                await db_manager.initialize()
+                logger.info("Authentication system initialized successfully")
+                logger.info(f"Auth required: {auth_required}, Rate limiting: {rate_limit_enabled}")
+
+        # Store startup function for later use
+        app.state.startup_event = startup_event
+
+        logger.info("Authentication system setup completed")
+
+    except Exception as e:
+        logger.error(f"Failed to initialize authentication system: {e}")
+        # Fall back to legacy auth if new system fails
+        logger.warning("Falling back to legacy authentication system")
+
+
+def get_auth_components():
+    """Get the initialized authentication components."""
+    if db_manager is None:
+        return {
+            "db_manager": None,
+            "api_key_manager": None,
+            "rate_limiter": None,
+            "auth_middleware": None
+        }
+
+    return {
+        "db_manager": db_manager,
+        "api_key_manager": api_key_manager,
+        "rate_limiter": rate_limiter,
+        "auth_middleware": auth_middleware
+    }

webscout/auth/config.py

@@ -0,0 +1,76 @@
+"""
+Configuration management for the Webscout API server.
+"""
+
+from typing import List, Dict, Optional, Any
+from webscout.Litlogger import Logger, LogLevel, LogFormat, ConsoleHandler
+import sys
+
+# Configuration constants
+DEFAULT_PORT = 8000
+DEFAULT_HOST = "0.0.0.0"
+
+# Setup logger
+logger = Logger(
+    name="webscout.api",
+    level=LogLevel.INFO,
+    handlers=[ConsoleHandler(stream=sys.stdout)],
+    fmt=LogFormat.DEFAULT
+)
+
+
+class ServerConfig:
+    """Centralized configuration management for the API server."""
+
+    def __init__(self):
+        self.api_key: Optional[str] = None
+        self.provider_map: Dict[str, Any] = {}
+        self.default_provider: str = "ChatGPT"
+        self.base_url: Optional[str] = None
+        self.host: str = DEFAULT_HOST
+        self.port: int = DEFAULT_PORT
+        self.debug: bool = False
+        self.cors_origins: List[str] = ["*"]
+        self.max_request_size: int = 10 * 1024 * 1024  # 10MB
+        self.request_timeout: int = 300  # 5 minutes
+        self.auth_required: bool = True  # New: Enable/disable authentication
+        self.rate_limit_enabled: bool = True  # New: Enable/disable rate limiting
+        self.default_rate_limit: int = 60  # Default rate limit for no-auth mode
+
+    def update(self, **kwargs) -> None:
+        """Update configuration with provided values."""
+        for key, value in kwargs.items():
+            if hasattr(self, key) and value is not None:
+                setattr(self, key, value)
+                logger.info(f"Config updated: {key} = {value}")
+
+    def validate(self) -> None:
+        """Validate configuration settings."""
+        if self.port < 1 or self.port > 65535:
+            raise ValueError(f"Invalid port number: {self.port}")
+
+        if self.default_provider not in self.provider_map and self.provider_map:
+            available_providers = list(set(v.__name__ for v in self.provider_map.values()))
+            logger.warning(f"Default provider '{self.default_provider}' not found. Available: {available_providers}")
+
+
+class AppConfig:
+    """Legacy configuration class for backward compatibility."""
+    api_key: Optional[str] = None
+    provider_map = {}
+    tti_provider_map = {}  # Add TTI provider map
+    default_provider = "ChatGPT"
+    default_tti_provider = "PollinationsAI"  # Add default TTI provider
+    base_url: Optional[str] = None
+    auth_required: bool = True  # New: Enable/disable authentication
+    rate_limit_enabled: bool = True  # New: Enable/disable rate limiting
+    default_rate_limit: int = 60  # Default rate limit for no-auth mode
+
+    @classmethod
+    def set_config(cls, **data):
+        """Set configuration values."""
+        for key, value in data.items():
+            setattr(cls, key, value)
+        # Sync with new config system
+        from .server import config
+        config.update(**data)