unrealon 1.0.9__py3-none-any.whl → 1.1.0__py3-none-any.whl

unrealon_llm/src/exceptions.py

@@ -1,392 +0,0 @@
-"""
-UnrealOn LLM Exceptions
-
-Custom exception classes for UnrealOn LLM platform with detailed error information.
-All exceptions follow KISS methodology with clear error messages and context.
-"""
-
-from typing import Any, Dict, Optional
-
-
-class LLMError(Exception):
-    """Base exception for all LLM operations"""
-    
-    def __init__(
-        self, 
-        message: str, 
-        error_code: Optional[str] = None,
-        context: Optional[Dict[str, Any]] = None
-    ):
-        super().__init__(message)
-        self.message = message
-        self.error_code = error_code
-        self.context = context or {}
-    
-    def __str__(self) -> str:
-        error_info = f"LLMError: {self.message}"
-        if self.error_code:
-            error_info += f" (Code: {self.error_code})"
-        return error_info
-
-
-class APIError(LLMError):
-    """Base class for API-related errors"""
-    pass
-
-
-class OpenRouterAPIError(APIError):
-    """OpenRouter API specific errors"""
-    pass
-
-
-class OpenAIAPIError(APIError):
-    """OpenAI API specific errors"""
-    pass
-
-
-class AnthropicAPIError(APIError):
-    """Anthropic API specific errors"""
-    pass
-
-
-class RateLimitError(APIError):
-    """API rate limit exceeded"""
-    
-    def __init__(
-        self, 
-        message: str = "API rate limit exceeded",
-        retry_after: Optional[int] = None,
-        **kwargs
-    ):
-        super().__init__(message, **kwargs)
-        self.retry_after = retry_after
-
-
-class APIQuotaExceededError(APIError):
-    """API quota exceeded"""
-    pass
-
-
-class ModelUnavailableError(APIError):
-    """Requested model is not available"""
-    
-    def __init__(
-        self, 
-        model_name: str,
-        available_models: Optional[list] = None,
-        **kwargs
-    ):
-        message = f"Model '{model_name}' is not available"
-        super().__init__(message, **kwargs)
-        self.model_name = model_name
-        self.available_models = available_models or []
-
-
-class NetworkError(APIError):
-    """Network connectivity issues"""
-    pass
-
-
-class AuthenticationError(APIError):
-    """API authentication failed"""
-    pass
-
-
-class CostLimitExceededError(LLMError):
-    """Cost limit exceeded"""
-    
-    def __init__(
-        self, 
-        current_cost: float,
-        limit: float,
-        **kwargs
-    ):
-        message = f"Cost limit exceeded: ${current_cost:.4f} > ${limit:.4f}"
-        super().__init__(message, **kwargs)
-        self.current_cost = current_cost
-        self.limit = limit
-
-
-class TokenLimitExceededError(LLMError):
-    """Token limit exceeded"""
-    
-    def __init__(
-        self, 
-        token_count: int,
-        limit: int,
-        **kwargs
-    ):
-        message = f"Token limit exceeded: {token_count} > {limit}"
-        super().__init__(message, **kwargs)
-        self.token_count = token_count
-        self.limit = limit
-
-
-class ValidationError(LLMError):
-    """Data validation errors"""
-    pass
-
-
-class HTMLParsingError(LLMError):
-    """HTML parsing and analysis errors"""
-    pass
-
-
-class HTMLTooLargeError(HTMLParsingError):
-    """HTML content too large for processing"""
-    
-    def __init__(
-        self, 
-        html_size: int,
-        max_size: int,
-        **kwargs
-    ):
-        message = f"HTML too large: {html_size} bytes > {max_size} bytes limit"
-        super().__init__(message, **kwargs)
-        self.html_size = html_size
-        self.max_size = max_size
-
-
-class PatternDetectionError(HTMLParsingError):
-    """Pattern detection failed"""
-    pass
-
-
-class SelectorGenerationError(HTMLParsingError):
-    """Selector generation failed"""
-    pass
-
-
-class SelectorValidationError(HTMLParsingError):
-    """Selector validation failed"""
-    
-    def __init__(
-        self, 
-        selector: str,
-        validation_message: str,
-        **kwargs
-    ):
-        message = f"Selector validation failed: '{selector}' - {validation_message}"
-        super().__init__(message, **kwargs)
-        self.selector = selector
-        self.validation_message = validation_message
-
-
-class TranslationError(LLMError):
-    """Translation operation errors"""
-    pass
-
-
-class LanguageDetectionError(TranslationError):
-    """Language detection failed"""
-    pass
-
-
-class TranslationQualityError(TranslationError):
-    """Translation quality below threshold"""
-    
-    def __init__(
-        self, 
-        quality_score: float,
-        threshold: float,
-        **kwargs
-    ):
-        message = f"Translation quality too low: {quality_score:.2f} < {threshold:.2f}"
-        super().__init__(message, **kwargs)
-        self.quality_score = quality_score
-        self.threshold = threshold
-
-
-class SchemaGenerationError(LLMError):
-    """Schema generation errors"""
-    pass
-
-
-class TypeInferenceError(SchemaGenerationError):
-    """Type inference failed"""
-    pass
-
-
-class CodeGenerationError(SchemaGenerationError):
-    """Generated code is invalid"""
-    
-    def __init__(
-        self, 
-        code_type: str,
-        syntax_error: str,
-        **kwargs
-    ):
-        message = f"{code_type} code generation failed: {syntax_error}"
-        super().__init__(message, **kwargs)
-        self.code_type = code_type
-        self.syntax_error = syntax_error
-
-
-class CacheError(LLMError):
-    """Cache operation errors"""
-    pass
-
-
-class CacheCorruptionError(CacheError):
-    """Cache data is corrupted"""
-    pass
-
-
-class ConfigurationError(LLMError):
-    """Configuration errors"""
-    pass
-
-
-class MissingAPIKeyError(ConfigurationError):
-    """API key is missing"""
-    
-    def __init__(
-        self, 
-        provider: str,
-        **kwargs
-    ):
-        message = f"API key missing for provider: {provider}"
-        super().__init__(message, **kwargs)
-        self.provider = provider
-
-
-class InvalidConfigurationError(ConfigurationError):
-    """Configuration is invalid"""
-    pass
-
-
-class TestingError(LLMError):
-    """Testing infrastructure errors"""
-    pass
-
-
-class MockSetupError(TestingError):
-    """Mock setup failed"""
-    pass
-
-
-class CostSimulationError(TestingError):
-    """Cost simulation failed"""
-    pass
-
-
-class ResponseParsingError(LLMError):
-    """Failed to parse LLM response"""
-    
-    def __init__(
-        self, 
-        response_content: str,
-        expected_format: str,
-        **kwargs
-    ):
-        message = f"Failed to parse response as {expected_format}"
-        super().__init__(message, **kwargs)
-        self.response_content = response_content[:200] + "..." if len(response_content) > 200 else response_content
-        self.expected_format = expected_format
-
-
-class ProcessingPipelineError(LLMError):
-    """Processing pipeline errors"""
-    
-    def __init__(
-        self, 
-        stage: str,
-        stage_error: Exception,
-        **kwargs
-    ):
-        message = f"Pipeline failed at stage '{stage}': {str(stage_error)}"
-        super().__init__(message, **kwargs)
-        self.stage = stage
-        self.stage_error = stage_error
-
-
-class RetryExhaustedError(LLMError):
-    """All retry attempts exhausted"""
-    
-    def __init__(
-        self, 
-        operation: str,
-        attempts: int,
-        last_error: Exception,
-        **kwargs
-    ):
-        message = f"Operation '{operation}' failed after {attempts} attempts"
-        super().__init__(message, **kwargs)
-        self.operation = operation
-        self.attempts = attempts
-        self.last_error = last_error
-
-
-# Convenience functions for common error patterns
-def raise_if_cost_exceeded(current_cost: float, limit: float) -> None:
-    """Raise CostLimitExceededError if cost exceeds limit"""
-    if current_cost > limit:
-        raise CostLimitExceededError(current_cost, limit)
-
-
-def raise_if_tokens_exceeded(token_count: int, limit: int) -> None:
-    """Raise TokenLimitExceededError if tokens exceed limit"""
-    if token_count > limit:
-        raise TokenLimitExceededError(token_count, limit)
-
-
-def raise_if_html_too_large(html_size: int, max_size: int) -> None:
-    """Raise HTMLTooLargeError if HTML exceeds size limit"""
-    if html_size > max_size:
-        raise HTMLTooLargeError(html_size, max_size)
-
-
-def wrap_api_error(provider: str, original_error: Exception) -> APIError:
-    """Wrap provider-specific API errors"""
-    error_message = str(original_error)
-    
-    if provider.lower() == "openrouter":
-        return OpenRouterAPIError(error_message, context={"original_error": original_error})
-    elif provider.lower() == "openai":
-        return OpenAIAPIError(error_message, context={"original_error": original_error})
-    elif provider.lower() == "anthropic":
-        return AnthropicAPIError(error_message, context={"original_error": original_error})
-    else:
-        return APIError(error_message, context={"provider": provider, "original_error": original_error})
-
-
-# Error code constants
-class ErrorCodes:
-    """Standard error codes for LLM operations"""
-    
-    # API errors
-    RATE_LIMIT = "RATE_LIMIT"
-    QUOTA_EXCEEDED = "QUOTA_EXCEEDED"
-    MODEL_UNAVAILABLE = "MODEL_UNAVAILABLE"
-    AUTHENTICATION_FAILED = "AUTH_FAILED"
-    NETWORK_ERROR = "NETWORK_ERROR"
-    
-    # Cost errors
-    COST_LIMIT_EXCEEDED = "COST_LIMIT"
-    TOKEN_LIMIT_EXCEEDED = "TOKEN_LIMIT"
-    
-    # HTML errors
-    HTML_TOO_LARGE = "HTML_TOO_LARGE"
-    PATTERN_DETECTION_FAILED = "PATTERN_FAILED"
-    SELECTOR_GENERATION_FAILED = "SELECTOR_FAILED"
-    SELECTOR_VALIDATION_FAILED = "SELECTOR_INVALID"
-    
-    # Translation errors
-    LANGUAGE_DETECTION_FAILED = "LANG_DETECT_FAILED"
-    TRANSLATION_QUALITY_LOW = "TRANSLATION_LOW_QUALITY"
-    
-    # Schema errors
-    TYPE_INFERENCE_FAILED = "TYPE_INFERENCE_FAILED"
-    CODE_GENERATION_FAILED = "CODE_GEN_FAILED"
-    
-    # Cache errors
-    CACHE_CORRUPTED = "CACHE_CORRUPTED"
-    
-    # Config errors
-    MISSING_API_KEY = "MISSING_API_KEY"
-    INVALID_CONFIG = "INVALID_CONFIG"
-    
-    # Processing errors
-    PIPELINE_FAILED = "PIPELINE_FAILED"
-    RETRY_EXHAUSTED = "RETRY_EXHAUSTED"
-    RESPONSE_PARSING_FAILED = "RESPONSE_PARSE_FAILED"

unrealon_llm/src/llm_config/__init__.py

@@ -1,20 +0,0 @@
-"""
-UnrealOn LLM Configuration
-
-Configuration management for UnrealOn LLM including logging setup,
-environment variable handling, and runtime configuration.
-"""
-
-from .logging_config import (
-    LoggingConfig,
-    setup_llm_logging,
-    get_logging_config_from_env,
-    configure_llm_logging,
-)
-
-__all__ = [
-    "LoggingConfig",
-    "setup_llm_logging",
-    "get_logging_config_from_env", 
-    "configure_llm_logging",
-]

unrealon_llm/src/llm_config/logging_config.py

@@ -1,178 +0,0 @@
-"""
-Logging Configuration for UnrealOn LLM
-
-Provides configuration management for the integrated SDK logging system.
-Handles environment variables, default settings, and initialization.
-"""
-
-import os
-from typing import Optional
-from pydantic import BaseModel, Field, ConfigDict
-from unrealon_sdk.src.dto.logging import SDKSeverity
-from unrealon_llm.src.llm_logging import initialize_llm_logger, get_llm_logger, LLMLogger
-
-
-class LoggingConfig(BaseModel):
-    """Configuration for UnrealOn LLM logging system."""
-    
-    # Basic logging settings
-    log_level: str = Field(default="INFO", description="Logging level (TRACE, DEBUG, INFO, WARNING, ERROR, CRITICAL)")
-    enable_console: bool = Field(default=True, description="Enable console logging output")
-    enable_websocket: bool = Field(default=True, description="Enable WebSocket logging for real-time streaming")
-    
-    # Session management
-    session_id: Optional[str] = Field(default=None, description="Custom session ID for tracking")
-    
-    # Log filtering and performance
-    min_cost_threshold_usd: float = Field(default=0.0001, description="Minimum cost to log (filters micro-transactions)")
-    log_token_details: bool = Field(default=True, description="Include token count details in logs")
-    log_html_size_details: bool = Field(default=True, description="Include HTML size details in logs")
-    
-    # Development settings
-    verbose_errors: bool = Field(default=True, description="Include full error traces in logs")
-    log_cache_operations: bool = Field(default=True, description="Log cache hits/misses/stores")
-    log_performance_metrics: bool = Field(default=True, description="Log performance metrics and thresholds")
-    
-    model_config = ConfigDict(
-        env_prefix="UNREALON_LLM_LOG_",
-        extra="ignore"
-    )
-
-
-def get_logging_config_from_env() -> LoggingConfig:
-    """
-    Create logging configuration from environment variables.
-    
-    Environment variables:
-    - UNREALON_LLM_LOG_LEVEL: Logging level (default: INFO)
-    - UNREALON_LLM_LOG_ENABLE_CONSOLE: Enable console output (default: true)
-    - UNREALON_LLM_LOG_ENABLE_WEBSOCKET: Enable WebSocket output (default: true)
-    - UNREALON_LLM_LOG_SESSION_ID: Custom session ID
-    - UNREALON_LLM_LOG_MIN_COST_THRESHOLD_USD: Minimum cost to log (default: 0.0001)
-    - UNREALON_LLM_LOG_TOKEN_DETAILS: Log token details (default: true)
-    - UNREALON_LLM_LOG_HTML_SIZE_DETAILS: Log HTML size details (default: true)
-    - UNREALON_LLM_LOG_VERBOSE_ERRORS: Include full error traces (default: true)
-    - UNREALON_LLM_LOG_CACHE_OPERATIONS: Log cache operations (default: true)
-    - UNREALON_LLM_LOG_PERFORMANCE_METRICS: Log performance metrics (default: true)
-    """
-    
-    # Helper function to parse boolean env vars
-    def parse_bool(value: str) -> bool:
-        return value.lower() in ("true", "1", "yes", "on")
-    
-    config_data = {}
-    
-    # Get values from environment
-    if log_level := os.getenv("UNREALON_LLM_LOG_LEVEL"):
-        config_data["log_level"] = log_level.upper()
-    
-    if enable_console := os.getenv("UNREALON_LLM_LOG_ENABLE_CONSOLE"):
-        config_data["enable_console"] = parse_bool(enable_console)
-    
-    if enable_websocket := os.getenv("UNREALON_LLM_LOG_ENABLE_WEBSOCKET"):
-        config_data["enable_websocket"] = parse_bool(enable_websocket)
-    
-    if session_id := os.getenv("UNREALON_LLM_LOG_SESSION_ID"):
-        config_data["session_id"] = session_id
-    
-    if min_cost_threshold := os.getenv("UNREALON_LLM_LOG_MIN_COST_THRESHOLD_USD"):
-        try:
-            config_data["min_cost_threshold_usd"] = float(min_cost_threshold)
-        except ValueError:
-            pass  # Use default if invalid
-    
-    if log_token_details := os.getenv("UNREALON_LLM_LOG_TOKEN_DETAILS"):
-        config_data["log_token_details"] = parse_bool(log_token_details)
-    
-    if log_html_size_details := os.getenv("UNREALON_LLM_LOG_HTML_SIZE_DETAILS"):
-        config_data["log_html_size_details"] = parse_bool(log_html_size_details)
-    
-    if verbose_errors := os.getenv("UNREALON_LLM_LOG_VERBOSE_ERRORS"):
-        config_data["verbose_errors"] = parse_bool(verbose_errors)
-    
-    if log_cache_operations := os.getenv("UNREALON_LLM_LOG_CACHE_OPERATIONS"):
-        config_data["log_cache_operations"] = parse_bool(log_cache_operations)
-    
-    if log_performance_metrics := os.getenv("UNREALON_LLM_LOG_PERFORMANCE_METRICS"):
-        config_data["log_performance_metrics"] = parse_bool(log_performance_metrics)
-    
-    return LoggingConfig(**config_data)
-
-
-def setup_llm_logging(config: Optional[LoggingConfig] = None) -> LLMLogger:
-    """
-    Set up UnrealOn LLM logging with the given configuration.
-    
-    Args:
-        config: Logging configuration. If None, loads from environment.
-        
-    Returns:
-        Initialized LLM logger instance.
-        
-    Example:
-        >>> from unrealon_llm.src.llm_config import setup_llm_logging
-        >>> logger = setup_llm_logging()
-        >>> # Now all LLM operations will be logged
-    """
-    if config is None:
-        config = get_logging_config_from_env()
-    
-    # Check if logger is already initialized
-    existing_logger = get_llm_logger()
-    if existing_logger:
-        return existing_logger
-    
-    # Initialize with config
-    return initialize_llm_logger(
-        session_id=config.session_id,
-        log_level=config.log_level,
-        enable_console=config.enable_console,
-        enable_websocket=config.enable_websocket,
-    )
-
-
-def configure_llm_logging(
-    log_level: str = "INFO",
-    enable_console: bool = True,
-    enable_websocket: bool = True,
-    session_id: Optional[str] = None,
-) -> LLMLogger:
-    """
-    Quick configuration function for UnrealOn LLM logging.
-    
-    Args:
-        log_level: Logging level (TRACE, DEBUG, INFO, WARNING, ERROR, CRITICAL)
-        enable_console: Enable console output
-        enable_websocket: Enable WebSocket output  
-        session_id: Custom session ID
-        
-    Returns:
-        Initialized LLM logger instance.
-        
-    Example:
-        >>> from unrealon_llm.src.llm_config import configure_llm_logging
-        >>> logger = configure_llm_logging(log_level="DEBUG", session_id="my-session")
-    """
-    config = LoggingConfig(
-        log_level=log_level,
-        enable_console=enable_console,
-        enable_websocket=enable_websocket,
-        session_id=session_id,
-    )
-    
-    return setup_llm_logging(config)
-
-
-# Auto-initialize logging if environment variables are present
-def _auto_initialize():
-    """Auto-initialize logging if environment variables indicate it should be enabled."""
-    if os.getenv("UNREALON_LLM_AUTO_INIT_LOGGING", "false").lower() in ("true", "1", "yes", "on"):
-        try:
-            setup_llm_logging()
-        except Exception:
-            # Silently fail auto-initialization to avoid breaking imports
-            pass
-
-
-# Run auto-initialization on module import
-_auto_initialize()

unrealon_llm/src/llm_logging/__init__.py

@@ -1,42 +0,0 @@
-"""
-UnrealOn LLM Logging Integration
-
-Integrates enterprise-grade logging from UnrealOn SDK with LLM-specific functionality.
-Provides structured logging for AI operations, cost tracking, and performance monitoring.
-"""
-
-from unrealon_sdk.src.enterprise.logging.development import (
-    DevelopmentLogger,
-    initialize_development_logger,
-    get_development_logger,
-    track_development_operation,
-)
-
-from unrealon_sdk.src.dto.logging import (
-    SDKEventType,
-    SDKSeverity,
-    SDKContext,
-    SDKDevelopmentEvent,
-)
-
-from .llm_events import LLMEventType, LLMContext
-from .llm_logger import LLMLogger, initialize_llm_logger, get_llm_logger
-
-__all__ = [
-    # SDK Logger components
-    "DevelopmentLogger",
-    "initialize_development_logger", 
-    "get_development_logger",
-    "track_development_operation",
-    "SDKEventType",
-    "SDKSeverity", 
-    "SDKContext",
-    "SDKDevelopmentEvent",
-    
-    # LLM-specific components
-    "LLMEventType",
-    "LLMContext", 
-    "LLMLogger",
-    "initialize_llm_logger",
-    "get_llm_logger",
-]