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

webscout/auth/schemas.py

@@ -1,103 +0,0 @@
-# webscout/auth/schemas.py
-
-from datetime import datetime
-from typing import Optional, Dict, Any
-from pydantic import BaseModel, Field
-
-
-class APIKeyCreateRequest(BaseModel):
-    """Request model for creating a new API key."""
-    username: str = Field(..., min_length=3, max_length=50, description="Username for the API key owner (required)")
-    telegram_id: str = Field(..., min_length=1, description="Telegram user ID (required)")
-    name: Optional[str] = Field(None, description="Optional name for the API key")
-    rate_limit: Optional[int] = Field(10, description="Rate limit per minute (default: 10)")
-    expires_in_days: Optional[int] = Field(None, description="Number of days until expiration")
-    metadata: Optional[Dict[str, Any]] = Field(default_factory=dict, description="Additional metadata")
-
-
-class APIKeyCreateResponse(BaseModel):
-    """Response model for API key creation."""
-    api_key: str = Field(..., description="The generated API key")
-    key_id: str = Field(..., description="Unique identifier for the API key")
-    user_id: str = Field(..., description="User ID associated with the API key")
-    name: Optional[str] = Field(None, description="Name of the API key")
-    created_at: datetime = Field(..., description="Creation timestamp")
-    expires_at: Optional[datetime] = Field(None, description="Expiration timestamp")
-    rate_limit: int = Field(..., description="Rate limit per minute")
-    
-    class Config:
-        json_encoders = {
-            datetime: lambda v: v.isoformat()
-        }
-
-
-class APIKeyValidationResponse(BaseModel):
-    """Response model for API key validation."""
-    valid: bool = Field(..., description="Whether the API key is valid")
-    user_id: Optional[str] = Field(None, description="User ID if key is valid")
-    key_id: Optional[str] = Field(None, description="Key ID if key is valid")
-    rate_limit: Optional[int] = Field(None, description="Rate limit per minute")
-    usage_count: Optional[int] = Field(None, description="Total usage count")
-    last_used_at: Optional[datetime] = Field(None, description="Last usage timestamp")
-    error: Optional[str] = Field(None, description="Error message if key is invalid")
-    
-    class Config:
-        json_encoders = {
-            datetime: lambda v: v.isoformat()
-        }
-
-
-class UserCreateRequest(BaseModel):
-    """Request model for creating a new user."""
-    username: str = Field(..., min_length=3, max_length=50, description="Username for the new user")
-    telegram_id: str = Field(..., min_length=1, description="Telegram user ID (required)")
-    metadata: Optional[Dict[str, Any]] = Field(default_factory=dict, description="Additional metadata")
-
-
-class UserResponse(BaseModel):
-    """Response model for user information."""
-    id: str = Field(..., description="User ID")
-    username: str = Field(..., description="Username")
-    telegram_id: str = Field(..., description="Telegram user ID")
-    created_at: datetime = Field(..., description="Creation timestamp")
-    updated_at: datetime = Field(..., description="Last update timestamp")
-    is_active: bool = Field(..., description="Whether the user is active")
-    metadata: Dict[str, Any] = Field(default_factory=dict, description="Additional metadata")
-    
-    class Config:
-        json_encoders = {
-            datetime: lambda v: v.isoformat()
-        }
-
-
-class RateLimitStatus(BaseModel):
-    """Response model for rate limit status."""
-    allowed: bool = Field(..., description="Whether the request is allowed")
-    limit: int = Field(..., description="Rate limit per minute")
-    remaining: int = Field(..., description="Remaining requests in current window")
-    reset_at: datetime = Field(..., description="When the rate limit resets")
-    retry_after: Optional[int] = Field(None, description="Seconds to wait before retry")
-    
-    class Config:
-        json_encoders = {
-            datetime: lambda v: v.isoformat()
-        }
-
-
-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")
-    database: str = Field(..., description="Database status")
-    timestamp: datetime = Field(..., description="Check timestamp")
-    
-    class Config:
-        json_encoders = {
-            datetime: lambda v: v.isoformat()
-        }

webscout/auth/simple_logger.py

@@ -1,236 +0,0 @@
-"""
-Simple database logging for no-auth mode.
-Logs API requests directly to Supabase without authentication.
-"""
-
-import os
-import uuid
-import asyncio
-from datetime import datetime, timezone
-from typing import Optional, Dict, Any
-import json
-
-from webscout.Litlogger import Logger, LogLevel, LogFormat, ConsoleHandler
-import sys
-
-# Setup logger
-logger = Logger(
-    name="webscout.api.simple_db",
-    level=LogLevel.INFO,
-    handlers=[ConsoleHandler(stream=sys.stdout)],
-    fmt=LogFormat.DEFAULT
-)
-
-try:
-    from supabase import create_client, Client
-    SUPABASE_AVAILABLE = True
-except ImportError:
-    logger.warning("Supabase not available. Install with: pip install supabase")
-    SUPABASE_AVAILABLE = False
-
-
-class SimpleRequestLogger:
-    """Simple request logger for no-auth mode."""
-    
-    def __init__(self):
-        self.supabase_client: Optional[Client] = None
-        self.initialize_supabase()
-    
-    def initialize_supabase(self):
-        """Initialize Supabase client if credentials are available."""
-        if not SUPABASE_AVAILABLE:
-            logger.warning("Supabase package not installed. Request logging disabled.")
-            return
-            
-        supabase_url = os.getenv("SUPABASE_URL")
-        supabase_key = os.getenv("SUPABASE_ANON_KEY")
-        
-        if supabase_url and supabase_key:
-            try:
-                self.supabase_client = create_client(supabase_url, supabase_key)
-                logger.info("Supabase client initialized for request logging")
-                
-            except Exception as e:
-                logger.error(f"Failed to initialize Supabase client: {e}")
-                self.supabase_client = None
-        else:
-            logger.info("Supabase credentials not found. Request logging disabled.")
-    
-    async def log_request(
-        self,
-        request_id: str,
-        ip_address: str,
-        model: str,
-        question: str,
-        answer: str,
-        provider: Optional[str] = None,
-        request_time: Optional[datetime] = None,
-        response_time: Optional[datetime] = None,
-        processing_time_ms: Optional[float] = None,
-        tokens_used: Optional[int] = None,
-        error: Optional[str] = None,
-        user_agent: Optional[str] = None
-    ) -> bool:
-        """
-        Log API request details to Supabase.
-        
-        Args:
-            request_id: Unique identifier for the request
-            ip_address: Client IP address
-            model: Model used for the request
-            question: User's question/prompt
-            answer: AI's response
-            provider: Provider used (e.g., ChatGPT, Claude, etc.)
-            request_time: When the request was received
-            response_time: When the response was sent
-            processing_time_ms: Processing time in milliseconds
-            tokens_used: Number of tokens consumed
-            error: Error message if any
-            user_agent: User agent string
-            
-        Returns:
-            bool: True if logged successfully, False otherwise
-        """
-        if not self.supabase_client:
-            # Still log to console for debugging
-            logger.info(f"Request {request_id}: {model} - {question[:100]}...")
-            return False
-        
-        if not request_time:
-            request_time = datetime.now(timezone.utc)
-        
-        if not response_time:
-            response_time = datetime.now(timezone.utc)
-        
-        try:
-            data = {
-                "request_id": request_id,
-                "ip_address": ip_address,
-                "model": model,
-                "provider": provider or "unknown",
-                "question": question[:2000] if question else "",  # Truncate long questions
-                "answer": answer[:5000] if answer else "",  # Truncate long answers
-                "request_time": request_time.isoformat(),
-                "response_time": response_time.isoformat(),
-                "processing_time_ms": processing_time_ms,
-                "tokens_used": tokens_used,
-                "error": error[:1000] if error else None,  # Truncate long errors
-                "user_agent": user_agent[:500] if user_agent else None,
-                "created_at": datetime.now(timezone.utc).isoformat()
-            }
-            
-            result = self.supabase_client.table("api_requests").insert(data).execute()
-            
-            if result.data:
-                logger.info(f"✅ Request {request_id} logged to database")
-                return True
-            else:
-                logger.error(f"❌ Failed to log request {request_id}: No data returned")
-                return False
-                
-        except Exception as e:
-            logger.error(f"❌ Failed to log request {request_id}: {e}")
-            return False
-    
-    async def get_recent_requests(self, limit: int = 10) -> Dict[str, Any]:
-        """Get recent API requests for monitoring."""
-        if not self.supabase_client:
-            return {"error": "Database not available", "requests": []}
-        
-        try:
-            result = self.supabase_client.table("api_requests")\
-                .select("request_id, ip_address, model, provider, created_at, processing_time_ms, error")\
-                .order("created_at", desc=True)\
-                .limit(limit)\
-                .execute()
-            
-            return {
-                "requests": result.data if result.data else [],
-                "count": len(result.data) if result.data else 0
-            }
-            
-        except Exception as e:
-            logger.error(f"Failed to get recent requests: {e}")
-            return {"error": str(e), "requests": []}
-    
-    async def get_stats(self) -> Dict[str, Any]:
-        """Get basic statistics about API usage."""
-        if not self.supabase_client:
-            return {"error": "Database not available"}
-        
-        try:
-            # Get total requests today
-            today = datetime.now(timezone.utc).date().isoformat()
-            
-            today_requests = self.supabase_client.table("api_requests")\
-                .select("request_id", count="exact")\
-                .gte("created_at", f"{today}T00:00:00Z")\
-                .execute()
-            
-            # Get requests by model (last 100)
-            model_requests = self.supabase_client.table("api_requests")\
-                .select("model")\
-                .order("created_at", desc=True)\
-                .limit(100)\
-                .execute()
-            
-            model_counts = {}
-            if model_requests.data:
-                for req in model_requests.data:
-                    model = req.get("model", "unknown")
-                    model_counts[model] = model_counts.get(model, 0) + 1
-            
-            return {
-                "today_requests": today_requests.count if hasattr(today_requests, 'count') else 0,
-                "model_usage": model_counts,
-                "available": True
-            }
-            
-        except Exception as e:
-            logger.error(f"Failed to get stats: {e}")
-            return {"error": str(e), "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."""
-    # Check for X-Forwarded-For header (common with proxies/load balancers)
-    forwarded_for = request.headers.get("X-Forwarded-For")
-    if forwarded_for:
-        # Take the first IP in the chain
-        return forwarded_for.split(",")[0].strip()
-    
-    # Check for X-Real-IP header
-    real_ip = request.headers.get("X-Real-IP")
-    if real_ip:
-        return real_ip.strip()
-    
-    # Fall back to direct client IP
-    return getattr(request.client, "host", "unknown")
-
-
-def generate_request_id() -> str:
-    """Generate a unique request ID."""
-    return str(uuid.uuid4())

webscout/search/engines/yahoo.py

@@ -1,65 +0,0 @@
-"""Yahoo search engine."""
-
-from __future__ import annotations
-
-from collections.abc import Mapping
-from secrets import token_urlsafe
-from typing import Any
-from urllib.parse import unquote_plus
-
-from ..base import BaseSearchEngine
-from ..results import TextResult
-
-
-def extract_url(u: str) -> str:
-    """Sanitize url."""
-    if "/RU=" in u:
-        start = u.find("/RU=") + 4
-        end = u.find("/RK=", start)
-        if end == -1:
-            end = len(u)
-        return unquote_plus(u[start:end])
-    return u
-
-
-class Yahoo(BaseSearchEngine[TextResult]):
-    """Yahoo search engine."""
-
-    name = "yahoo"
-    category = "text"
-    provider = "bing"
-
-    search_url = "https://search.yahoo.com/search"
-    search_method = "GET"
-
-    items_xpath = "//div[contains(@class, 'relsrch')]"
-    elements_xpath: Mapping[str, str] = {
-        "title": ".//div[contains(@class, 'Title')]//h3//text()",
-        "href": ".//div[contains(@class, 'Title')]//a/@href",
-        "body": ".//div[contains(@class, 'Text')]//text()",
-    }
-
-    def build_payload(
-        self, query: str, region: str, safesearch: str, timelimit: str | None, page: int = 1, **kwargs: Any
-    ) -> dict[str, Any]:
-        """Build a payload for the search request."""
-        self.search_url = (
-            f"https://search.yahoo.com/search;_ylt={token_urlsafe(24 * 3 // 4)};_ylu={token_urlsafe(47 * 3 // 4)}"
-        )
-        payload = {"p": query}
-        if page > 1:
-            payload["b"] = f"{(page - 1) * 7 + 1}"
-        if timelimit:
-            payload["btf"] = timelimit
-        return payload
-
-    def post_extract_results(self, results: list[TextResult]) -> list[TextResult]:
-        """Post-process search results."""
-        post_results = []
-        for result in results:
-            if result.href.startswith("https://www.bing.com/aclick?"):
-                continue
-            if "/RU=" in result.href:
-                result.href = extract_url(result.href)
-            post_results.append(result)
-        return post_results

webscout/search/engines/yahoo_news.py

@@ -1,64 +0,0 @@
-"""Yahoo news search engine."""
-
-from __future__ import annotations
-
-from collections.abc import Mapping
-from secrets import token_urlsafe
-from typing import Any
-
-from ..base import BaseSearchEngine
-from ..results import NewsResult
-
-
-def extract_image(u: str) -> str:
-    """Sanitize image url."""
-    if u and u.startswith("data:image"):
-        return ""
-    return u
-
-
-def extract_source(s: str) -> str:
-    """Remove ' via Yahoo' from string."""
-    return s.replace(" via Yahoo", "") if s else s
-
-
-class YahooNews(BaseSearchEngine[NewsResult]):
-    """Yahoo news search engine."""
-
-    name = "yahoo"
-    category = "news"
-    provider = "bing"
-
-    search_url = "https://news.search.yahoo.com/search"
-    search_method = "GET"
-
-    items_xpath = "//div[contains(@class, 'NewsArticle')]"
-    elements_xpath: Mapping[str, str] = {
-        "date": ".//span[contains(@class, 'fc-2nd')]//text()",
-        "title": ".//h4//a//text()",
-        "url": ".//h4//a/@href",
-        "body": ".//p//text()",
-        "image": ".//img/@src",
-        "source": ".//span[contains(@class, 's-source')]//text()",
-    }
-
-    def build_payload(
-        self, query: str, region: str, safesearch: str, timelimit: str | None, page: int = 1, **kwargs: Any
-    ) -> dict[str, Any]:
-        """Build a payload for the search request."""
-        self.search_url = (
-            f"https://news.search.yahoo.com/search;_ylt={token_urlsafe(24 * 3 // 4)};_ylu={token_urlsafe(47 * 3 // 4)}"
-        )
-        payload = {"p": query}
-        if page > 1:
-            payload["b"] = f"{(page - 1) * 10 + 1}"
-        if timelimit:
-            payload["btf"] = timelimit
-        return payload
-
-    def post_extract_results(self, results: list[NewsResult]) -> list[NewsResult]:
-        """Post-process search results."""
-        for result in results:
-            result.image = extract_image(result.image)
-            result.source = extract_source(result.source)
-        return results