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

unrealon_sdk/src/dto/resource_pooling.py

@@ -1,128 +0,0 @@
-"""
-Resource Pooling DTOs - Data Transfer Objects for resource pool management.
-
-This module contains all Pydantic models, enums, and dataclasses related to resource pooling,
-separated from business logic for clean architecture and reusability.
-
-Components:
-- Resource lifecycle states and scaling strategies
-- Pool configuration and resource metadata
-- Resource management and monitoring models
-- Performance tracking and metrics
-"""
-
-from typing import Dict, Optional, Any
-from datetime import datetime, timezone
-from enum import Enum
-from dataclasses import dataclass, field
-
-from pydantic import BaseModel, Field, ConfigDict
-
-# Import from existing concurrency DTOs
-from .concurrency import ResourceType
-
-
-class ResourceLifecycleState(str, Enum):
-    """Resource lifecycle states."""
-
-    CREATING = "creating"
-    INITIALIZING = "initializing"
-    READY = "ready"
-    IN_USE = "in_use"
-    IDLE = "idle"
-    VALIDATING = "validating"
-    CLEANING = "cleaning"
-    DESTROYING = "destroying"
-    DESTROYED = "destroyed"
-    ERROR = "error"
-
-
-class PoolScalingStrategy(str, Enum):
-    """Pool scaling strategies."""
-
-    FIXED = "fixed"  # Fixed pool size
-    DYNAMIC = "dynamic"  # Dynamic scaling based on demand
-    PREDICTIVE = "predictive"  # Predictive scaling based on patterns
-    AGGRESSIVE = "aggressive"  # Aggressive scaling for high performance
-    CONSERVATIVE = "conservative"  # Conservative scaling for stability
-
-
-@dataclass
-class ResourceMetadata:
-    """Resource metadata and tracking information."""
-
-    resource_id: str
-    resource_type: ResourceType
-    created_at: datetime
-    last_used: datetime
-    usage_count: int = 0
-    error_count: int = 0
-    last_error: Optional[str] = None
-    lifecycle_state: ResourceLifecycleState = ResourceLifecycleState.CREATING
-    tags: Dict[str, str] = field(default_factory=dict)
-    health_score: float = 1.0  # 0.0 = unhealthy, 1.0 = perfect health
-    performance_metrics: Dict[str, float] = field(default_factory=dict)
-
-
-class PoolConfig(BaseModel):
-    """Resource pool configuration model."""
-
-    model_config = ConfigDict(extra="forbid")
-
-    # Pool identification
-    pool_name: str = Field(..., description="Pool name")
-    resource_type: ResourceType = Field(..., description="Type of resources in pool")
-
-    # Size configuration
-    min_size: int = Field(default=1, description="Minimum pool size")
-    max_size: int = Field(default=10, description="Maximum pool size")
-    initial_size: int = Field(default=2, description="Initial pool size")
-    scaling_strategy: PoolScalingStrategy = Field(
-        default=PoolScalingStrategy.DYNAMIC, description="Scaling strategy"
-    )
-
-    # Scaling parameters
-    scale_up_threshold: float = Field(
-        default=0.8, description="Scale up when utilization > threshold"
-    )
-    scale_down_threshold: float = Field(
-        default=0.3, description="Scale down when utilization < threshold"
-    )
-    scale_factor: float = Field(default=1.5, description="Factor for scaling operations")
-
-    # Timeout settings
-    acquisition_timeout_seconds: float = Field(
-        default=30.0, description="Resource acquisition timeout"
-    )
-    idle_timeout_seconds: float = Field(default=300.0, description="Resource idle timeout")
-    max_lifetime_seconds: Optional[float] = Field(
-        default=None, description="Maximum resource lifetime"
-    )
-
-    # Health and validation
-    enable_health_checks: bool = Field(default=True, description="Enable health checks")
-    health_check_interval_seconds: float = Field(default=60.0, description="Health check interval")
-    validation_on_acquire: bool = Field(default=True, description="Validate on acquire")
-    validation_on_return: bool = Field(default=False, description="Validate on return")
-
-    # Performance features
-    enable_warmup: bool = Field(default=True, description="Enable pool warmup")
-    warmup_size: int = Field(default=2, description="Warmup pool size")
-    enable_preallocation: bool = Field(default=False, description="Enable resource preallocation")
-
-    # Monitoring and debugging
-    enable_leak_detection: bool = Field(default=True, description="Enable leak detection")
-    leak_detection_threshold_seconds: float = Field(
-        default=3600.0, description="Leak detection threshold"
-    )
-
-
-__all__ = [
-    # Enums
-    "ResourceLifecycleState",
-    "PoolScalingStrategy",
-    # Data classes
-    "ResourceMetadata",
-    # Configuration models
-    "PoolConfig",
-]

unrealon_sdk/src/dto/structured_logging.py

@@ -1,112 +0,0 @@
-"""
-Structured Logging Data Transfer Objects
-
-DTO models for enterprise structured logging service functionality.
-These models provide type-safe structured logging operations and configuration.
-"""
-
-from datetime import datetime, timezone
-from typing import Dict, List, Optional, Any, Callable
-from enum import Enum
-from dataclasses import dataclass, field
-from collections import deque
-import threading
-import asyncio
-
-from pydantic import BaseModel, Field, ConfigDict
-
-
-@dataclass
-class LogBuffer:
-    """Thread-safe buffer for batching log entries using auto-generated models."""
-
-    max_size: int = 100
-    flush_interval_seconds: float = 5.0
-
-    # Buffer storage (will hold LogEntryMessage objects)
-    entries: deque[Any] = field(default_factory=deque)
-    lock: threading.Lock = field(default_factory=threading.Lock)
-
-    # Flush callback
-    flush_callback: Optional[Any] = None
-
-    # Background task
-    _flush_task: Optional[asyncio.Task[None]] = None
-    _should_stop: bool = False
-
-    def add_entry(self, entry: Any) -> None:
-        """Add entry to buffer, trigger flush if needed."""
-        with self.lock:
-            self.entries.append(entry)
-
-            # Auto-flush if buffer is full - use non-blocking approach
-            if len(self.entries) >= self.max_size:
-                # Schedule flush without blocking current context
-                try:
-                    loop = asyncio.get_running_loop()
-                    if loop and not loop.is_closed():
-                        loop.call_soon_threadsafe(
-                            lambda: asyncio.create_task(self._flush_now())
-                        )
-                except RuntimeError:
-                    # No event loop running - skip flush, will be handled by auto-flush
-                    pass
-
-    async def start_auto_flush(self) -> None:
-        """Start automatic flushing task."""
-        if self._flush_task is None:
-            self._flush_task = asyncio.create_task(self._auto_flush_loop())
-
-    async def stop_auto_flush(self) -> None:
-        """Stop automatic flushing and flush remaining entries."""
-        self._should_stop = True
-        if self._flush_task:
-            self._flush_task.cancel()
-            try:
-                await self._flush_task
-            except asyncio.CancelledError:
-                pass
-
-        # Final flush
-        await self._flush_now()
-
-    async def _auto_flush_loop(self) -> None:
-        """Background auto-flush loop."""
-        while not self._should_stop:
-            try:
-                await asyncio.sleep(self.flush_interval_seconds)
-                await self._flush_now()
-            except asyncio.CancelledError:
-                break
-            except Exception as e:
-                # Note: logger import needed in actual usage
-                print(f"Error in auto-flush loop: {e}")
-
-    async def _flush_now(self) -> None:
-        """Flush current buffer contents."""
-        entries_to_flush = []
-
-        with self.lock:
-            if self.entries:
-                entries_to_flush = list(self.entries)
-                self.entries.clear()
-
-        if entries_to_flush and self.flush_callback:
-            try:
-                await self._call_flush_callback(entries_to_flush)
-            except Exception as e:
-                print(f"Error in flush callback: {e}")
-
-    async def _call_flush_callback(self, entries: List[Any]) -> None:
-        """Call flush callback, handling both sync and async callbacks."""
-        if self.flush_callback is not None:
-            if asyncio.iscoroutinefunction(self.flush_callback):
-                await self.flush_callback(entries)
-            else:
-                self.flush_callback(entries)
-
-
-__all__ = [
-    # Buffer models
-    "LogBuffer",
-]

unrealon_sdk/src/dto/task_scheduling.py

@@ -1,121 +0,0 @@
-"""
-Task Scheduling DTOs - Data Transfer Objects for task scheduling system.
-
-This module contains all Pydantic models, enums, and dataclasses related to task scheduling,
-separated from business logic for clean architecture and reusability.
-
-Components:
-- Task scheduling types and strategies
-- Schedule information and dependency management
-- Task progress tracking and configuration
-- Scheduler configuration and metrics
-"""
-
-from typing import Optional, List, Dict, Any
-from datetime import datetime, timezone, timedelta
-from enum import Enum
-from dataclasses import dataclass, field
-
-from pydantic import BaseModel, Field, ConfigDict
-
-
-class ScheduleType(str, Enum):
-    """Task scheduling types."""
-
-    IMMEDIATE = "immediate"  # Execute immediately
-    DELAYED = "delayed"  # Execute after delay
-    SCHEDULED = "scheduled"  # Execute at specific time
-    RECURRING = "recurring"  # Recurring execution
-    CRON = "cron"  # Cron-style scheduling
-
-
-class TaskSchedulerStrategy(str, Enum):
-    """Task scheduling strategies."""
-
-    FIFO = "fifo"  # First In First Out
-    PRIORITY = "priority"  # Priority-based
-    DEADLINE = "deadline"  # Deadline-based (Earliest Deadline First)
-    SHORTEST_JOB = "shortest_job"  # Shortest Job First
-    FAIR_SHARE = "fair_share"  # Fair share scheduling
-    ADAPTIVE = "adaptive"  # Adaptive based on performance
-
-
-@dataclass
-class ScheduleInfo:
-    """Task scheduling information."""
-
-    schedule_type: ScheduleType
-    scheduled_time: Optional[datetime] = None
-    delay_seconds: Optional[float] = None
-    cron_expression: Optional[str] = None
-    repeat_interval: Optional[timedelta] = None
-    max_executions: Optional[int] = None
-    execution_count: int = 0
-    last_execution: Optional[datetime] = None
-    next_execution: Optional[datetime] = None
-
-
-@dataclass
-class TaskDependency:
-    """Task dependency relationship."""
-
-    task_id: str
-    depends_on: str
-    dependency_type: str = "completion"  # completion, data, resource
-    optional: bool = False
-    timeout_seconds: Optional[float] = None
-
-
-@dataclass
-class TaskProgress:
-    """Task execution progress tracking."""
-
-    task_id: str
-    current_step: int = 0
-    total_steps: int = 1
-    progress_percent: float = 0.0
-    status_message: str = ""
-    started_at: Optional[datetime] = None
-    estimated_completion: Optional[datetime] = None
-    last_update: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
-
-
-class TaskSchedulerConfig(BaseModel):
-    """Task scheduler configuration model."""
-
-    model_config = ConfigDict(extra="forbid")
-
-    # Core settings
-    max_concurrent_tasks: int = Field(default=100, description="Maximum concurrent tasks")
-    default_timeout_seconds: float = Field(default=300.0, description="Default task timeout")
-    max_retries: int = Field(default=3, description="Maximum retry attempts")
-    retry_backoff_factor: float = Field(default=2.0, description="Retry backoff multiplier")
-
-    # Dead letter queue
-    enable_dead_letter_queue: bool = Field(default=True, description="Enable dead letter queue")
-    dead_letter_max_size: int = Field(default=1000, description="Dead letter queue max size")
-
-    # Scheduling
-    schedule_resolution_seconds: float = Field(default=1.0, description="Schedule resolution")
-    dependency_timeout_seconds: float = Field(default=3600.0, description="Dependency timeout")
-    strategy: TaskSchedulerStrategy = Field(
-        default=TaskSchedulerStrategy.PRIORITY, description="Scheduling strategy"
-    )
-
-    # Persistence and caching
-    enable_task_persistence: bool = Field(default=False, description="Enable task persistence")
-    enable_result_caching: bool = Field(default=True, description="Enable result caching")
-    cache_ttl_seconds: float = Field(default=3600.0, description="Cache TTL in seconds")
-
-
-__all__ = [
-    # Enums
-    "ScheduleType",
-    "TaskSchedulerStrategy",
-    # Data classes
-    "ScheduleInfo",
-    "TaskDependency",
-    "TaskProgress",
-    # Configuration models
-    "TaskSchedulerConfig",
-]

unrealon_sdk/src/dto/websocket.py

@@ -1,55 +0,0 @@
-"""
-WebSocket-related Data Transfer Objects
-
-Custom DTO models for WebSocket connection management and state tracking.
-"""
-
-from datetime import datetime
-from typing import Optional
-from enum import Enum
-
-from pydantic import BaseModel, Field, ConfigDict
-
-
-class WebSocketConnectionState(str, Enum):
-    """
-    WebSocket connection state constants.
-    
-    Compatible with WebSocket client events and internal state management.
-    """
-    
-    DISCONNECTED = "disconnected"
-    CONNECTING = "connecting"
-    CONNECTED = "connected"
-    RECONNECTING = "reconnecting"
-    ERROR = "error"
-
-
-class WebSocketStateInfo(BaseModel):
-    """
-    Type-safe WebSocket connection state model.
-
-    Replaces Dict[str, str] usage to comply with CRITICAL_REQUIREMENTS.md.
-    Provides structured state information for WebSocket connections.
-    """
-
-    model_config = ConfigDict(validate_assignment=True, extra="forbid")
-
-    # Core connection state
-    status: WebSocketConnectionState = Field(..., description="Connection status")
-    session_id: Optional[str] = Field(None, description="Session identifier")
-    last_ping: Optional[str] = Field(None, description="Last ping timestamp")
-    connection_time: Optional[str] = Field(None, description="Connection establishment time")
-
-    # Additional state fields
-    connected: bool = Field(default=False, description="Connection established")
-    connecting: bool = Field(default=False, description="Connection in progress")
-    error: Optional[str] = Field(None, description="Last error message")
-    last_connected: Optional[str] = Field(None, description="Last successful connection time")
-    reconnect_count: int = Field(default=0, description="Number of reconnection attempts")
-
-
-__all__ = [
-    "WebSocketConnectionState",
-    "WebSocketStateInfo",
-]

unrealon_sdk/src/enterprise/__init__.py

@@ -1,59 +0,0 @@
-"""
-UnrealOn SDK Enterprise Services
-
-Layer 3: Infrastructure Services - Core enterprise-grade components
-providing intelligent proxy management, structured logging, performance
-monitoring, and error recovery capabilities.
-
-Enterprise Features:
-- Intelligent proxy rotation with geographic awareness
-- Real-time structured logging via WebSocket
-- Performance metrics collection and analysis
-- Automatic error recovery and circuit breakers
-- Health monitoring and alerting
-- Intelligent caching with TTL management
-
-Quick Start:
-```python
-from unrealon_sdk import AdapterClient, AdapterConfig
-from unrealon_sdk.src.enterprise import ProxyManager, LoggingService, MonitoringManager
-
-config = AdapterConfig(api_key="up_dev_your_api_key")
-adapter = AdapterClient(config)
-
-# Enterprise services are automatically initialized
-# Just use the adapter client normally!
-```
-
-These services power the enterprise-grade capabilities of the UnrealOn SDK.
-"""
-
-from .proxy_manager import ProxyManager
-from .logging.service import LoggingService
-from .logging.development import (
-    DevelopmentLogger,
-    initialize_development_logger,
-    get_development_logger,
-    track_development_operation,
-    SDKEventType,
-    SDKSeverity,
-    SDKContext,
-)
-
-# These will be implemented next
-# from .monitoring_manager import MonitoringManager
-# from .error_recovery import ErrorRecoveryManager
-
-__all__ = [
-    "ProxyManager",
-    "LoggingService",
-    "DevelopmentLogger",
-    "initialize_development_logger",
-    "get_development_logger",
-    "track_development_operation",
-    "SDKEventType",
-    "SDKSeverity",
-    "SDKContext",
-    # "MonitoringManager",
-    # "ErrorRecoveryManager",
-]