unrealon 1.1.6__py3-none-any.whl → 2.0.4__py3-none-any.whl

unrealon_core/models/websocket/tasks.py

@@ -0,0 +1,275 @@
+"""
+Task WebSocket Models.
+
+Strictly typed models for task assignments and results.
+No raw dictionaries - all data structures are Pydantic models.
+
+Phase 2: Core Systems - WebSocket Bridge
+"""
+
+from typing import Optional, List, Union
+from pydantic import Field, ConfigDict, field_validator, HttpUrl
+
+from ..base import UnrealOnBaseModel
+from .base import WebSocketMessage, MessageType
+
+
+class TaskParameters(UnrealOnBaseModel):
+    """Task-specific parameters - strictly typed."""
+    
+    model_config = ConfigDict(
+        validate_assignment=True,
+        extra="forbid"
+    )
+    
+    selectors: Optional[List[str]] = Field(
+        default=None,
+        description="CSS selectors for parsing"
+    )
+    
+    wait_for: Optional[str] = Field(
+        default=None,
+        description="Element to wait for before parsing"
+    )
+    
+    scroll_to_bottom: bool = Field(
+        default=False,
+        description="Whether to scroll to bottom"
+    )
+    
+    screenshot: bool = Field(
+        default=False,
+        description="Whether to take screenshot"
+    )
+    
+    user_agent: Optional[str] = Field(
+        default=None,
+        description="Custom user agent"
+    )
+    
+    headers: Optional[List[str]] = Field(
+        default=None,
+        description="Custom headers as key:value pairs"
+    )
+
+
+class TaskMetadata(UnrealOnBaseModel):
+    """Task metadata - strictly typed."""
+    
+    model_config = ConfigDict(
+        validate_assignment=True,
+        extra="forbid"
+    )
+    
+    source: Optional[str] = Field(
+        default=None,
+        description="Task source system"
+    )
+    
+    batch_id: Optional[str] = Field(
+        default=None,
+        description="Batch identifier"
+    )
+    
+    user_id: Optional[str] = Field(
+        default=None,
+        description="User who created the task"
+    )
+    
+    tags: List[str] = Field(
+        default_factory=list,
+        description="Task tags"
+    )
+
+
+class TaskAssignmentData(UnrealOnBaseModel):
+    """Task assignment data payload - strictly typed."""
+    
+    model_config = ConfigDict(
+        validate_assignment=True,
+        extra="forbid"
+    )
+    
+    task_id: str = Field(
+        min_length=1,
+        description="Unique task identifier"
+    )
+    
+    task_type: str = Field(
+        min_length=1,
+        description="Type of task to execute"
+    )
+    
+    url: HttpUrl = Field(
+        description="Target URL for the task"
+    )
+    
+    parameters: TaskParameters = Field(
+        default_factory=TaskParameters,
+        description="Task-specific parameters"
+    )
+    
+    priority: str = Field(
+        default="normal",
+        pattern=r"^(low|normal|high|urgent|critical)$",
+        description="Task priority level"
+    )
+    
+    timeout_seconds: float = Field(
+        default=300.0,
+        ge=30.0,
+        le=3600.0,
+        description="Task timeout in seconds"
+    )
+    
+    retry_count: int = Field(
+        default=3,
+        ge=0,
+        le=10,
+        description="Number of retries allowed"
+    )
+    
+    metadata: TaskMetadata = Field(
+        default_factory=TaskMetadata,
+        description="Additional task metadata"
+    )
+
+
+class TaskAssignmentMessage(WebSocketMessage):
+    """Task assignment message (Server → Driver)."""
+    
+    model_config = ConfigDict(
+        validate_assignment=True,
+        extra="forbid"
+    )
+    
+    type: MessageType = Field(
+        default=MessageType.TASK_ASSIGN,
+        frozen=True
+    )
+    
+    data: TaskAssignmentData = Field(
+        description="Task assignment data"
+    )
+
+
+class TaskResultData(UnrealOnBaseModel):
+    """Task result data - strictly typed."""
+    
+    model_config = ConfigDict(
+        validate_assignment=True,
+        extra="forbid"
+    )
+    
+    # Basic fields
+    title: Optional[str] = Field(
+        default=None,
+        description="Extracted title"
+    )
+    
+    description: Optional[str] = Field(
+        default=None,
+        description="Extracted description"
+    )
+    
+    price: Optional[str] = Field(
+        default=None,
+        description="Extracted price"
+    )
+    
+    images: List[str] = Field(
+        default_factory=list,
+        description="Extracted image URLs"
+    )
+    
+    links: List[str] = Field(
+        default_factory=list,
+        description="Extracted links"
+    )
+    
+    # Custom fields for specific parsers
+    custom_fields: List[str] = Field(
+        default_factory=list,
+        description="Custom extracted fields as key:value pairs"
+    )
+
+
+class TaskResultPayload(UnrealOnBaseModel):
+    """Task result payload - strictly typed."""
+    
+    model_config = ConfigDict(
+        validate_assignment=True,
+        extra="forbid"
+    )
+    
+    task_id: str = Field(
+        description="Task identifier"
+    )
+    
+    status: str = Field(
+        pattern=r"^(completed|failed|timeout|cancelled)$",
+        description="Task completion status"
+    )
+    
+    result: Optional[TaskResultData] = Field(
+        default=None,
+        description="Task result data (if successful)"
+    )
+    
+    error_message: Optional[str] = Field(
+        default=None,
+        description="Error message (if failed)"
+    )
+    
+    error_code: Optional[str] = Field(
+        default=None,
+        description="Error code (if failed)"
+    )
+    
+    execution_time_seconds: float = Field(
+        default=0.0,
+        ge=0.0,
+        description="Task execution time in seconds"
+    )
+    
+    screenshot_url: Optional[str] = Field(
+        default=None,
+        description="Screenshot URL (if taken)"
+    )
+    
+    metadata: TaskMetadata = Field(
+        default_factory=TaskMetadata,
+        description="Additional result metadata"
+    )
+    
+    @field_validator('result')
+    @classmethod
+    def validate_result(cls, v: Optional[TaskResultData], info) -> Optional[TaskResultData]:
+        """Validate result based on status."""
+        status = info.data.get('status')
+        
+        if status == 'completed' and v is None:
+            raise ValueError("Result is required for completed tasks")
+        
+        if status != 'completed' and v is not None:
+            raise ValueError("Result should be None for non-completed tasks")
+        
+        return v
+
+
+class TaskResultMessage(WebSocketMessage):
+    """Task result message (Driver → Server)."""
+    
+    model_config = ConfigDict(
+        validate_assignment=True,
+        extra="forbid"
+    )
+    
+    type: MessageType = Field(
+        default=MessageType.TASK_RESULT,
+        frozen=True
+    )
+    
+    data: TaskResultPayload = Field(
+        description="Task result data"
+    )

unrealon_core/models/websocket/utils.py

@@ -0,0 +1,153 @@
+"""
+WebSocket Message Utilities.
+
+Utility functions for creating WebSocket messages.
+Strictly typed - no raw dictionaries.
+
+Phase 2: Core Systems - WebSocket Bridge
+"""
+
+from typing import Optional, List
+from datetime import datetime
+
+from .errors import ErrorMessage, ErrorData, ErrorDetails, AckMessage, AckData
+from ...utils.time import utc_now
+
+
+def create_error_message(
+    error_code: str,
+    error_message: str,
+    correlation_id: Optional[str] = None,
+    field_errors: Optional[List[str]] = None,
+    stack_trace: Optional[str] = None,
+    retry_after: Optional[int] = None
+) -> ErrorMessage:
+    """
+    Create an error message with strict typing.
+    
+    Args:
+        error_code: Error code identifier
+        error_message: Human-readable error message
+        correlation_id: ID of the message this is responding to
+        field_errors: List of field validation errors
+        stack_trace: Stack trace if available
+        retry_after: Retry after seconds if retryable
+        
+    Returns:
+        Strictly typed ErrorMessage
+    """
+    details = None
+    if field_errors or stack_trace:
+        details = ErrorDetails(
+            field_errors=field_errors or [],
+            stack_trace=stack_trace,
+            timestamp=utc_now().isoformat()
+        )
+    
+    error_data = ErrorData(
+        error_code=error_code,
+        error_message=error_message,
+        details=details,
+        retry_after=retry_after
+    )
+    
+    return ErrorMessage(
+        correlation_id=correlation_id,
+        data=error_data
+    )
+
+
+def create_ack_message(
+    correlation_id: str,
+    message: Optional[str] = None,
+    processing_time_ms: Optional[float] = None
+) -> AckMessage:
+    """
+    Create an acknowledgment message with strict typing.
+    
+    Args:
+        correlation_id: ID of the message being acknowledged
+        message: Optional acknowledgment message
+        processing_time_ms: Processing time in milliseconds
+        
+    Returns:
+        Strictly typed AckMessage
+    """
+    ack_data = AckData(
+        acknowledged=True,
+        message=message,
+        processing_time_ms=processing_time_ms
+    )
+    
+    return AckMessage(
+        correlation_id=correlation_id,
+        data=ack_data
+    )
+
+
+def create_validation_error_message(
+    validation_errors: List[str],
+    correlation_id: Optional[str] = None
+) -> ErrorMessage:
+    """
+    Create a validation error message.
+    
+    Args:
+        validation_errors: List of validation error messages
+        correlation_id: ID of the message this is responding to
+        
+    Returns:
+        Strictly typed ErrorMessage for validation errors
+    """
+    return create_error_message(
+        error_code="VALIDATION_ERROR",
+        error_message="Message validation failed",
+        correlation_id=correlation_id,
+        field_errors=validation_errors
+    )
+
+
+def create_timeout_error_message(
+    operation: str,
+    timeout_seconds: float,
+    correlation_id: Optional[str] = None
+) -> ErrorMessage:
+    """
+    Create a timeout error message.
+    
+    Args:
+        operation: Operation that timed out
+        timeout_seconds: Timeout duration
+        correlation_id: ID of the message this is responding to
+        
+    Returns:
+        Strictly typed ErrorMessage for timeout errors
+    """
+    return create_error_message(
+        error_code="TIMEOUT_ERROR",
+        error_message=f"Operation '{operation}' timed out after {timeout_seconds} seconds",
+        correlation_id=correlation_id,
+        retry_after=int(timeout_seconds * 2)  # Suggest retry after double the timeout
+    )
+
+
+def create_connection_error_message(
+    reason: str,
+    correlation_id: Optional[str] = None
+) -> ErrorMessage:
+    """
+    Create a connection error message.
+    
+    Args:
+        reason: Connection error reason
+        correlation_id: ID of the message this is responding to
+        
+    Returns:
+        Strictly typed ErrorMessage for connection errors
+    """
+    return create_error_message(
+        error_code="CONNECTION_ERROR",
+        error_message=f"Connection error: {reason}",
+        correlation_id=correlation_id,
+        retry_after=30  # Suggest retry after 30 seconds
+    )

unrealon_core/models/websocket_session.py

@@ -0,0 +1,144 @@
+"""
+WebSocket Session Models
+
+Strictly typed models for WebSocket session management.
+Following critical requirements - no raw Dict[str, Any].
+
+Phase 2: Core Systems - WebSocket Session
+"""
+
+from datetime import datetime
+from typing import Optional, List
+from pydantic import BaseModel, Field, ConfigDict
+
+from .base import UnrealOnBaseModel
+
+
+class DriverSession(UnrealOnBaseModel):
+    """Driver WebSocket session information."""
+    
+    model_config = ConfigDict(
+        validate_assignment=True,
+        extra="forbid"
+    )
+    
+    driver_id: str = Field(description="Driver ID")
+    driver_type: str = Field(description="Driver type")
+    connection_id: str = Field(description="WebSocket connection ID")
+    connected_at: datetime = Field(description="Connection timestamp")
+    last_seen: datetime = Field(description="Last activity timestamp")
+    capabilities: List[str] = Field(description="Driver capabilities")
+    status: str = Field(default="connected", description="Connection status")
+    active_tasks: int = Field(default=0, description="Number of active tasks")
+
+
+class ConnectionStats(UnrealOnBaseModel):
+    """WebSocket connection statistics."""
+    
+    model_config = ConfigDict(
+        validate_assignment=True,
+        extra="forbid"
+    )
+    
+    total_connections: int = Field(description="Total connections made")
+    active_connections: int = Field(description="Currently active connections")
+    messages_sent: int = Field(description="Total messages sent")
+    messages_received: int = Field(description="Total messages received")
+    errors: int = Field(description="Number of errors")
+    uptime_seconds: float = Field(description="Server uptime in seconds")
+
+
+class BridgeStats(UnrealOnBaseModel):
+    """WebSocket bridge statistics."""
+    
+    model_config = ConfigDict(
+        validate_assignment=True,
+        extra="forbid"
+    )
+    
+    active_connections: int = Field(description="Active WebSocket connections")
+    total_messages: int = Field(description="Total messages processed")
+    arq_jobs_sent: int = Field(description="ARQ jobs sent")
+    arq_jobs_failed: int = Field(description="ARQ jobs failed")
+    registered_drivers: int = Field(description="Number of registered drivers")
+    uptime_seconds: float = Field(description="Bridge uptime in seconds")
+
+
+class ConfigurationData(UnrealOnBaseModel):
+    """Configuration data for drivers."""
+    
+    model_config = ConfigDict(
+        validate_assignment=True,
+        extra="forbid"
+    )
+    
+    log_level: Optional[str] = Field(default=None, description="Logging level")
+    batch_size: Optional[int] = Field(default=None, description="Batch size for operations")
+    timeout_seconds: Optional[float] = Field(default=None, description="Operation timeout")
+    proxy_enabled: Optional[bool] = Field(default=None, description="Whether proxy is enabled")
+    max_retries: Optional[int] = Field(default=None, description="Maximum retry attempts")
+
+
+class ComponentDetails(UnrealOnBaseModel):
+    """Component details for dashboard."""
+    
+    model_config = ConfigDict(
+        validate_assignment=True,
+        extra="forbid"
+    )
+    
+    name: str = Field(description="Component name")
+    timestamp: str = Field(description="Timestamp ISO string")
+    health: Optional["ComponentHealth"] = Field(default=None, description="Health information")
+    metrics: "ComponentMetrics" = Field(description="Component metrics")
+    alerts: List["ComponentAlert"] = Field(description="Component alerts")
+
+
+class ComponentHealth(UnrealOnBaseModel):
+    """Component health information."""
+    
+    model_config = ConfigDict(
+        validate_assignment=True,
+        extra="forbid"
+    )
+    
+    status: str = Field(description="Health status")
+    last_check: str = Field(description="Last check timestamp")
+    uptime_seconds: float = Field(description="Uptime in seconds")
+    failure_rate: float = Field(description="Failure rate percentage")
+    check_count: int = Field(description="Total health checks")
+
+
+class ComponentMetrics(UnrealOnBaseModel):
+    """Component metrics information."""
+    
+    model_config = ConfigDict(
+        validate_assignment=True,
+        extra="forbid"
+    )
+    
+    metric_name: str = Field(description="Metric name")
+    metric_type: str = Field(description="Metric type")
+    current_value: float = Field(description="Current value")
+    total_samples: int = Field(description="Total samples")
+    last_updated: str = Field(description="Last updated timestamp")
+
+
+class ComponentAlert(UnrealOnBaseModel):
+    """Component alert information."""
+    
+    model_config = ConfigDict(
+        validate_assignment=True,
+        extra="forbid"
+    )
+    
+    alert_id: str = Field(description="Alert ID")
+    rule_name: str = Field(description="Alert rule name")
+    severity: str = Field(description="Alert severity")
+    message: str = Field(description="Alert message")
+    timestamp: str = Field(description="Alert timestamp")
+    component_name: Optional[str] = Field(default=None, description="Related component")
+
+
+# Update forward references
+ComponentDetails.model_rebuild()

unrealon_core/monitoring/__init__.py

@@ -0,0 +1,43 @@
+"""
+Monitoring Package
+
+Basic monitoring and health checks for UnrealOn RPC system.
+Following critical requirements - max 500 lines, 100% Pydantic v2.
+
+Phase 2: Core Systems - Monitoring
+"""
+
+from .health_check import (
+    HealthStatus, HealthCheckResult, ComponentHealth,
+    HealthChecker, health_check_decorator
+)
+from .metrics import (
+    MetricType, MetricValue, Metric,
+    MetricsCollector, counter, gauge, histogram, timer
+)
+from .alerts import (
+    AlertSeverity, AlertRule, Alert,
+    AlertManager, alert_on_condition
+)
+from .dashboard import (
+    DashboardData, SystemStatus,
+    MonitoringDashboard, get_system_overview
+)
+
+__all__ = [
+    # Health checks
+    'HealthStatus', 'HealthCheckResult', 'ComponentHealth',
+    'HealthChecker', 'health_check_decorator',
+    
+    # Metrics
+    'MetricType', 'MetricValue', 'Metric',
+    'MetricsCollector', 'counter', 'gauge', 'histogram', 'timer',
+    
+    # Alerts
+    'AlertSeverity', 'AlertRule', 'Alert',
+    'AlertManager', 'alert_on_condition',
+    
+    # Dashboard
+    'DashboardData', 'SystemStatus',
+    'MonitoringDashboard', 'get_system_overview',
+]