webscout 2025.10.15__py3-none-any.whl → 2025.10.16__py3-none-any.whl

webscout/server/config.py

@@ -0,0 +1,84 @@
+"""
+Configuration management for the Webscout API server.
+"""
+
+import os
+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.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 = False
+        self.rate_limit_enabled: bool = False
+        self.request_logging_enabled: bool = os.getenv("WEBSCOUT_REQUEST_LOGGING", "true").lower() == "true"  # Enable request logging by default
+
+    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."""
+    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 = False
+    rate_limit_enabled: bool = False
+    request_logging_enabled: bool = os.getenv("WEBSCOUT_REQUEST_LOGGING", "true").lower() == "true"  # Enable request logging by default
+
+    @classmethod
+    def set_config(cls, **data):
+        """Set configuration values."""
+        # Filter out auth-related keys
+        auth_keys = {'api_key'}
+        filtered_data = {k: v for k, v in data.items() if k not in auth_keys}
+
+        for key, value in filtered_data.items():
+            setattr(cls, key, value)
+        # Sync with new config system
+        try:
+            from .server import get_config
+            config = get_config()
+            config.update(**filtered_data)
+        except ImportError:
+            # Handle case where server module is not available
+            pass

webscout/{auth → server}/request_processing.py

@@ -16,8 +16,7 @@ import sys
 
 from .request_models import Message, ChatCompletionRequest
 from .exceptions import APIError, clean_text
-from .models import RequestLog
-from .auth_system import get_auth_components
+
 from .simple_logger import log_api_request, get_client_ip, generate_request_id
 from .config import AppConfig
 
@@ -33,9 +32,9 @@ logger = Logger(
 async def log_request(request_id: str, ip_address: str, model_used: str, question: str,
                      answer: str, response_time_ms: int, status_code: int = 200,
                      error_message: str = None, provider: str = None, request_obj=None):
-    """Log API request to database."""
+    """Log API request."""
     try:
-        # Use simple logger for no-auth mode if request logging is enabled
+        # Use simple logger if request logging is enabled
         if AppConfig.request_logging_enabled:
             user_agent = None
             if request_obj:
@@ -52,30 +51,6 @@ async def log_request(request_id: str, ip_address: str, model_used: str, questio
                 error=error_message,
                 user_agent=user_agent
             )
-        
-        # Also use the existing auth system logging if available
-        auth_manager, db_manager, _ = get_auth_components()
-        
-        if db_manager:
-            request_log = RequestLog(
-                id=None,  # Will be auto-generated
-                request_id=request_id,
-                ip_address=ip_address,
-                model_used=model_used,
-                question=question,
-                answer=answer,
-                user_id=None,  # No auth mode
-                api_key_id=None,  # No auth mode
-                created_at=datetime.now(timezone.utc),
-                response_time_ms=response_time_ms,
-                status_code=status_code,
-                error_message=error_message,
-                metadata={}
-            )
-            
-            await db_manager.create_request_log(request_log)
-            logger.debug(f"Logged request {request_id} to auth database")
-        
     except Exception as e:
         logger.error(f"Failed to log request {request_id}: {e}")
         # Don't raise exception to avoid breaking the main request flow

webscout/{auth → server}/routes.py

@@ -12,7 +12,6 @@ from typing import Any
 from fastapi import FastAPI, Request, Body, Query
 from fastapi.responses import JSONResponse
 from fastapi.exceptions import RequestValidationError
-from fastapi.security import APIKeyHeader
 from starlette.exceptions import HTTPException as StarletteHTTPException
 from starlette.status import (
     HTTP_422_UNPROCESSABLE_ENTITY,
@@ -28,7 +27,6 @@ from .request_models import (
     ErrorResponse
 )
 from .schemas import (
-    APIKeyCreateRequest, APIKeyCreateResponse, APIKeyValidationResponse,
     HealthCheckResponse
 )
 from .exceptions import APIError
@@ -40,10 +38,9 @@ from .request_processing import (
     process_messages, prepare_provider_params,
     handle_streaming_response, handle_non_streaming_response
 )
-from .auth_system import get_auth_components
 from .simple_logger import request_logger
 from ..search import DuckDuckGoSearch, YepSearch
-from webscout.Bing_search import BingSearch
+from ..search import BingSearch
 
 # Setup logger
 logger = Logger(
@@ -59,29 +56,6 @@ class Api:
     
     def __init__(self, app: FastAPI) -> None:
         self.app = app
-        self.get_api_key = APIKeyHeader(name="authorization", auto_error=False)
-
-    def register_authorization(self):
-        """Register legacy authorization middleware."""
-        @self.app.middleware("http")
-        async def authorization(request: Request, call_next):
-            if AppConfig.api_key is not None:
-                auth_header = await self.get_api_key(request)
-                path = request.url.path
-                if path.startswith("/v1"):  # Only protect /v1 routes
-                    if auth_header is None:
-                        return JSONResponse(
-                            status_code=HTTP_401_UNAUTHORIZED,
-                            content={"error": {"message": "API key required", "type": "authentication_error"}}
-                        )
-                    if auth_header.startswith("Bearer "):
-                        auth_header = auth_header[7:]
-                    if not secrets.compare_digest(AppConfig.api_key, auth_header):
-                        return JSONResponse(
-                            status_code=HTTP_403_FORBIDDEN,
-                            content={"error": {"message": "Invalid API key", "type": "authentication_error"}}
-                        )
-            return await call_next(request)
 
     def register_validation_exception_handler(self):
         """Register comprehensive exception handlers."""
@@ -162,7 +136,6 @@ class Api:
         """Register all API routes."""
         self._register_model_routes()
         self._register_chat_routes()
-        self._register_auth_routes()
         self._register_websearch_routes()
         self._register_monitoring_routes()
 
@@ -407,105 +380,7 @@ class Api:
                     "internal_error"
                 )
 
-    def _register_auth_routes(self):
-        """Register authentication routes."""
-        # Only register auth endpoints if authentication is required
-        if not AppConfig.auth_required:
-            logger.info("Auth endpoints are disabled (no-auth mode)")
-            return
-        auth_components = get_auth_components()
-        api_key_manager = auth_components.get("api_key_manager")
 
-        @self.app.post(
-            "/v1/auth/generate-key",
-            response_model=APIKeyCreateResponse,
-            tags=["Authentication"],
-            description="Generate a new API key for a user."
-        )
-        async def generate_api_key(request: APIKeyCreateRequest = Body(...)):
-            """Generate a new API key."""
-            if not api_key_manager:
-                raise APIError("Authentication system not initialized", HTTP_500_INTERNAL_SERVER_ERROR)
-
-            try:
-                api_key, user = await api_key_manager.create_api_key(
-                    username=request.username,
-                    telegram_id=request.telegram_id,
-                    name=request.name,
-                    rate_limit=request.rate_limit or 10,
-                    expires_in_days=request.expires_in_days
-                )
-
-                return APIKeyCreateResponse(
-                    api_key=api_key.key,
-                    key_id=api_key.id,
-                    user_id=user.id,
-                    name=api_key.name,
-                    created_at=api_key.created_at,
-                    expires_at=api_key.expires_at,
-                    rate_limit=api_key.rate_limit
-                )
-            except Exception as e:
-                logger.error(f"Error generating API key: {e}")
-                raise APIError(f"Failed to generate API key: {str(e)}", HTTP_500_INTERNAL_SERVER_ERROR)
-
-        @self.app.get(
-            "/v1/auth/validate",
-            response_model=APIKeyValidationResponse,
-            tags=["Authentication"],
-            description="Validate an API key and return its status."
-        )
-        async def validate_api_key(request: Request):
-            """Validate an API key."""
-            if not api_key_manager:
-                raise APIError("Authentication system not initialized", HTTP_500_INTERNAL_SERVER_ERROR)
-
-            auth_header = request.headers.get("authorization")
-            if not auth_header:
-                return APIKeyValidationResponse(valid=False, error="No authorization header provided")
-
-            # Extract API key
-            api_key = auth_header
-            if auth_header.startswith("Bearer "):
-                api_key = auth_header[7:]
-
-            try:
-                is_valid, api_key_obj, error_msg = await api_key_manager.validate_api_key(api_key)
-
-                if is_valid and api_key_obj:
-                    return APIKeyValidationResponse(
-                        valid=True,
-                        user_id=api_key_obj.user_id,
-                        key_id=api_key_obj.id,
-                        rate_limit=api_key_obj.rate_limit,
-                        usage_count=api_key_obj.usage_count,
-                        last_used_at=api_key_obj.last_used_at
-                    )
-                else:
-                    return APIKeyValidationResponse(valid=False, error=error_msg)
-            except Exception as e:
-                logger.error(f"Error validating API key: {e}")
-                return APIKeyValidationResponse(valid=False, error="Internal validation error")
-
-        @self.app.get(
-            "/health",
-            response_model=HealthCheckResponse,
-            tags=["Health"],
-            description="Health check endpoint for the API and database."
-        )
-        async def health_check():
-            """Health check endpoint."""
-            db_status = "unknown"
-            db_manager = auth_components.get("db_manager")
-            if db_manager:
-                status_info = db_manager.get_status()
-                db_status = f"{status_info['type']} - {status_info['status']}"
-
-            return HealthCheckResponse(
-                status="healthy",
-                database=db_status,
-                timestamp=datetime.now(timezone.utc)
-            )
 
     def _register_websearch_routes(self):
         """Register web search endpoint."""
@@ -583,18 +458,15 @@ class Api:
                 }
 
     def _register_monitoring_routes(self):
-        """Register monitoring and analytics routes for no-auth mode."""
+        """Register monitoring and analytics routes."""
 
         @self.app.get(
             "/monitor/requests",
             tags=["Monitoring"],
-            description="Get recent API requests (no-auth mode only)"
+            description="Get recent API requests"
         )
         async def get_recent_requests(limit: int = Query(10, description="Number of recent requests to fetch")):
             """Get recent API requests for monitoring."""
-            if AppConfig.auth_required:
-                return {"error": "Monitoring is only available in no-auth mode"}
-            
             try:
                 return await request_logger.get_recent_requests(limit)
             except Exception as e:
@@ -603,13 +475,10 @@ class Api:
         @self.app.get(
             "/monitor/stats",
             tags=["Monitoring"], 
-            description="Get API usage statistics (no-auth mode only)"
+            description="Get API usage statistics"
         )
         async def get_api_stats():
             """Get API usage statistics."""
-            if AppConfig.auth_required:
-                return {"error": "Monitoring is only available in no-auth mode"}
-            
             try:
                 return await request_logger.get_stats()
             except Exception as e:
@@ -618,24 +487,13 @@ class Api:
         @self.app.get(
             "/monitor/health",
             tags=["Monitoring"],
-            description="Health check with database status"
+            description="Health check"
         )
         async def enhanced_health_check():
-            """Enhanced health check including database connectivity."""
+            """Enhanced health check."""
             try:
-                # Check database connectivity
-                db_status = "disconnected"
-                if request_logger.supabase_client:
-                    try:
-                        # Try a simple query to check connectivity
-                        result = request_logger.supabase_client.table("api_requests").select("id").limit(1).execute()
-                        db_status = "connected"
-                    except Exception as e:
-                        db_status = f"error: {str(e)[:100]}"
-                
                 return {
                     "status": "healthy",
-                    "database": db_status,
                     "auth_required": AppConfig.auth_required,
                     "rate_limit_enabled": AppConfig.rate_limit_enabled,
                     "request_logging_enabled": AppConfig.request_logging_enabled,

webscout/server/schemas.py

@@ -0,0 +1,23 @@
+# webscout/server/schemas.py
+
+from datetime import datetime
+from typing import Optional, Dict, Any
+from pydantic import BaseModel, Field
+
+
+class ErrorResponse(BaseModel):
+    """Standard error response model."""
+    error: str = Field(..., description="Error message")
+    code: str = Field(..., description="Error code")
+    details: Optional[Dict[str, Any]] = Field(None, description="Additional error details")
+
+
+class HealthCheckResponse(BaseModel):
+    """Health check response model."""
+    status: str = Field(..., description="Service status")
+    timestamp: datetime = Field(..., description="Check timestamp")
+
+    class Config:
+        json_encoders = {
+            datetime: lambda v: v.isoformat()
+        }

webscout/{auth → server}/server.py

@@ -25,7 +25,7 @@ from webscout.Litlogger import Logger, LogLevel, LogFormat, ConsoleHandler
 from .config import ServerConfig, AppConfig
 from .routes import Api
 from .providers import initialize_provider_map, initialize_tti_provider_map
-from .auth_system import initialize_auth_system
+
 
 # Configuration constants
 DEFAULT_PORT = 8000
@@ -138,12 +138,7 @@ def create_app():
         allow_headers=["*"],
     )
 
-    # Initialize authentication system with configuration
-    initialize_auth_system(
-        app,
-        auth_required=AppConfig.auth_required,
-        rate_limit_enabled=AppConfig.rate_limit_enabled
-    )
+
     # Add startup event handler
     @app.on_event("startup")
     async def startup():
@@ -175,42 +170,33 @@ def create_app_debug():
 def start_server(
     port: int = DEFAULT_PORT,
     host: str = DEFAULT_HOST,
-    api_key: str = None,
     default_provider: str = None,
     base_url: str = None,
     workers: int = 1,
     log_level: str = 'info',
     debug: bool = False,
-    no_auth: bool = False,
-    no_rate_limit: bool = False
 ):
     """Start the API server with the given configuration."""
     run_api(
         host=host,
         port=port,
-        api_key=api_key,
         default_provider=default_provider,
         base_url=base_url,
         workers=workers,
         log_level=log_level,
         debug=debug,
-        no_auth=no_auth,
-        no_rate_limit=no_rate_limit,
     )
 
 
 def run_api(
     host: str = '0.0.0.0',
     port: int = None,
-    api_key: str = None,
     default_provider: str = None,
     base_url: str = None,
     debug: bool = False,
     workers: int = 1,
     log_level: str = 'info',
     show_available_providers: bool = True,
-    no_auth: bool = False,
-    no_rate_limit: bool = False,
 ) -> None:
     """Run the API server with configuration."""
     print("Starting Webscout OpenAI API server...")
@@ -218,11 +204,11 @@ def run_api(
         port = DEFAULT_PORT
         
     AppConfig.set_config(
-        api_key=api_key,
+        api_key=None,
         default_provider=default_provider or AppConfig.default_provider,
         base_url=base_url,
-        auth_required=not no_auth,
-        rate_limit_enabled=not no_rate_limit
+        auth_required=False,
+        rate_limit_enabled=False
     )
 
     if show_available_providers:
@@ -243,18 +229,10 @@ def run_api(
         print(f"Docs URL: {api_endpoint_base}/docs")
 
         # Show authentication status
-        if no_auth:
-            print(f"Authentication: 🔓 DISABLED (No-Auth Mode)")
-        elif api_key:
-            print(f"Authentication: 🔐 Legacy API Key")
-        else:
-            print(f"Authentication: 🔑 Enhanced API Keys")
+        print(f"Authentication: 🔓 DISABLED")
 
         # Show rate limiting status
-        if no_rate_limit:
-            print(f"Rate Limiting: ⚡ DISABLED")
-        else:
-            print(f"Rate Limiting: 🛡️  Enabled ({AppConfig.default_rate_limit}/min)")
+        print(f"Rate Limiting: ⚡ DISABLED")
 
         print(f"Default Provider: {AppConfig.default_provider}")
         print(f"Workers: {workers}")
@@ -291,7 +269,7 @@ def run_api(
         print("\nUse Ctrl+C to stop the server.")
         print("=" * 40 + "\n")
 
-    uvicorn_app_str = "webscout.auth.server:create_app_debug" if debug else "webscout.auth.server:create_app"
+    uvicorn_app_str = "webscout.server.server:create_app_debug" if debug else "webscout.server.server:create_app"
 
     # Configure uvicorn settings
     uvicorn_config = {
@@ -322,24 +300,18 @@ def main():
     default_host = os.getenv('WEBSCOUT_HOST', DEFAULT_HOST)
     default_workers = int(os.getenv('WEBSCOUT_WORKERS', '1'))
     default_log_level = os.getenv('WEBSCOUT_LOG_LEVEL', 'info')
-    default_api_key = os.getenv('WEBSCOUT_API_KEY', os.getenv('API_KEY'))
     default_provider = os.getenv('WEBSCOUT_DEFAULT_PROVIDER', os.getenv('DEFAULT_PROVIDER'))
     default_base_url = os.getenv('WEBSCOUT_BASE_URL', os.getenv('BASE_URL'))
     default_debug = os.getenv('WEBSCOUT_DEBUG', os.getenv('DEBUG', 'false')).lower() == 'true'
-    default_no_auth = os.getenv('WEBSCOUT_NO_AUTH', 'false').lower() == 'true'
-    default_no_rate_limit = os.getenv('WEBSCOUT_NO_RATE_LIMIT', 'false').lower() == 'true'
 
     parser = argparse.ArgumentParser(description='Start Webscout OpenAI-compatible API server')
     parser.add_argument('--port', type=int, default=default_port, help=f'Port to run the server on (default: {default_port})')
     parser.add_argument('--host', type=str, default=default_host, help=f'Host to bind the server to (default: {default_host})')
     parser.add_argument('--workers', type=int, default=default_workers, help=f'Number of worker processes (default: {default_workers})')
     parser.add_argument('--log-level', type=str, default=default_log_level, choices=['debug', 'info', 'warning', 'error', 'critical'], help=f'Log level (default: {default_log_level})')
-    parser.add_argument('--api-key', type=str, default=default_api_key, help='API key for authentication (optional)')
     parser.add_argument('--default-provider', type=str, default=default_provider, help='Default provider to use (optional)')
     parser.add_argument('--base-url', type=str, default=default_base_url, help='Base URL for the API (optional, e.g., /api/v1)')
     parser.add_argument('--debug', action='store_true', default=default_debug, help='Run in debug mode')
-    parser.add_argument('--no-auth', action='store_true', default=default_no_auth, help='Disable authentication (no API keys required)')
-    parser.add_argument('--no-rate-limit', action='store_true', default=default_no_rate_limit, help='Disable rate limiting (unlimited requests)')
     args = parser.parse_args()
 
     # Print configuration summary
@@ -349,9 +321,8 @@ def main():
     print(f"  Workers: {args.workers}")
     print(f"  Log Level: {args.log_level}")
     print(f"  Debug Mode: {args.debug}")
-    print(f"  No-Auth Mode: {'🔓 ENABLED' if args.no_auth else '🔐 Disabled'}")
-    print(f"  No Rate Limit: {'⚡ ENABLED' if args.no_rate_limit else '🛡️  Disabled'}")
-    print(f"  API Key: {'Set' if args.api_key else 'Not set'}")
+    print(f"  Authentication: 🔓 DISABLED")
+    print(f"  Rate Limiting: ⚡ DISABLED")
     print(f"  Default Provider: {args.default_provider or 'Not set'}")
     print(f"  Base URL: {args.base_url or 'Not set'}")
     print()
@@ -361,12 +332,9 @@ def main():
         port=args.port,
         workers=args.workers,
         log_level=args.log_level,
-        api_key=args.api_key,
         default_provider=args.default_provider,
         base_url=args.base_url,
-        debug=args.debug,
-        no_auth=args.no_auth,
-        no_rate_limit=args.no_rate_limit
+        debug=args.debug
     )
 
 

webscout/server/simple_logger.py

@@ -0,0 +1,84 @@
+"""
+Simple logger for no-auth mode.
+"""
+
+import asyncio
+from datetime import datetime, timezone
+from typing import Optional, Dict, Any
+import sys
+from webscout.Litlogger import Logger, LogLevel, LogFormat, ConsoleHandler
+
+# Setup logger
+logger = Logger(
+    name="webscout.api.simple_db",
+    level=LogLevel.INFO,
+    handlers=[ConsoleHandler(stream=sys.stdout)],
+    fmt=LogFormat.DEFAULT
+)
+
+class SimpleRequestLogger:
+    """Simple request logger for no-auth mode."""
+
+    def __init__(self):
+        logger.info("Simple request logger initialized (no database).")
+
+    async def log_request(
+        self,
+        request_id: str,
+        ip_address: str,
+        model: str,
+        question: str,
+        answer: str,
+        **kwargs
+    ) -> bool:
+        """Logs request details to the console."""
+        logger.info(f"Request {request_id}: model={model}, ip={ip_address}")
+        return True
+
+    async def get_recent_requests(self, limit: int = 10) -> Dict[str, Any]:
+        """Returns empty list of recent requests."""
+        logger.info("get_recent_requests called, but no database is configured.")
+        return {"requests": [], "count": 0}
+
+    async def get_stats(self) -> Dict[str, Any]:
+        """Returns empty stats."""
+        logger.info("get_stats called, but no database is configured.")
+        return {"error": "No database configured.", "available": False}
+
+# Global instance
+request_logger = SimpleRequestLogger()
+
+async def log_api_request(
+    request_id: str,
+    ip_address: str,
+    model: str,
+    question: str,
+    answer: str,
+    **kwargs
+) -> bool:
+    """Convenience function to log API requests."""
+    return await request_logger.log_request(
+        request_id=request_id,
+        ip_address=ip_address,
+        model=model,
+        question=question,
+        answer=answer,
+        **kwargs
+    )
+
+def get_client_ip(request) -> str:
+    """Extract client IP address from request."""
+    forwarded_for = request.headers.get("X-Forwarded-For")
+    if forwarded_for:
+        return forwarded_for.split(",")[0].strip()
+    
+    real_ip = request.headers.get("X-Real-IP")
+    if real_ip:
+        return real_ip.strip()
+    
+    return getattr(request.client, "host", "unknown")
+
+def generate_request_id() -> str:
+    """Generate a unique request ID."""
+    import uuid
+    return str(uuid.uuid4())

webscout/version.py

@@ -1,2 +1,2 @@
-__version__ = "2025.10.15"
+__version__ = "2025.10.16"
 __prog__ = "webscout"

webscout/version.py.bak

@@ -1,2 +1,2 @@
-__version__ = ""
+__version__ = "2025.10.15"
 __prog__ = "webscout"