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

unrealon_driver/src/services/scheduler_service.py

@@ -1,489 +0,0 @@
-"""
-Scheduler Service for UnrealOn Driver v3.0
-
-Full scheduler implementation with human-readable intervals and enterprise monitoring.
-Based on the proven architecture from v2.0 with modern enhancements.
-
-CRITICAL REQUIREMENTS COMPLIANCE:
-- ✅ Absolute imports only 
-- ✅ Pydantic v2 models everywhere
-- ✅ Complete type annotations
-- ✅ Full unrealon_sdk integration
-"""
-
-import asyncio
-import re
-import time
-from datetime import datetime, timedelta
-from typing import Any, Dict, List, Optional, Callable, Union
-from enum import Enum
-
-from pydantic import BaseModel, Field, ConfigDict, field_validator
-
-from unrealon_sdk.src.dto.task_scheduling import TaskSchedulerConfig, ScheduleInfo, TaskProgress
-from unrealon_sdk.src.enterprise.logging.development import get_development_logger
-from unrealon_sdk.src.dto.logging import SDKContext, SDKEventType
-
-from unrealon_driver.src.core.exceptions import SchedulingError
-from unrealon_driver.src.dto.services import SchedulerConfig
-
-
-class ScheduledTaskStatus(str, Enum):
-    """Task status enumeration."""
-
-    PENDING = "pending"
-    RUNNING = "running"
-    COMPLETED = "completed"
-    FAILED = "failed"
-    CANCELLED = "cancelled"
-
-
-class ScheduleExpression(BaseModel):
-    """Pydantic model for schedule expression parsing."""
-
-    model_config = ConfigDict(validate_assignment=True, extra="forbid")
-
-    expression: str = Field(..., description="Human-readable schedule expression")
-    interval_seconds: int = Field(..., ge=1, description="Parsed interval in seconds")
-
-    @field_validator("expression")
-    @classmethod
-    def validate_expression(cls, v: str) -> str:
-        """Validate schedule expression format."""
-        v = v.lower().strip()
-
-        # Allowed patterns
-        patterns = [
-            r"^\d+[smhd]$",  # 30s, 5m, 1h, 2d
-            r"^(minutely|hourly|daily|weekly|monthly)$",  # Named intervals
-            r"^(weekdays|weekends|business_hours)$",  # Special intervals
-        ]
-
-        if not any(re.match(pattern, v) for pattern in patterns):
-            raise ValueError(f"Invalid schedule expression: {v}")
-
-        return v
-
-    @classmethod
-    def parse(cls, expression: str) -> "ScheduleExpression":
-        """Parse human-readable expression to seconds."""
-        expr = expression.lower().strip()
-
-        # Parse time units (30s, 5m, 1h, 2d)
-        if re.match(r"^\d+[smhd]$", expr):
-            number = int(expr[:-1])
-            unit = expr[-1]
-
-            multipliers = {"s": 1, "m": 60, "h": 3600, "d": 86400}
-
-            seconds = number * multipliers[unit]
-            return cls(expression=expression, interval_seconds=seconds)
-
-        # Named intervals
-        named_intervals = {
-            "minutely": 60,
-            "hourly": 3600,
-            "daily": 86400,
-            "weekly": 604800,
-            "monthly": 2592000,  # 30 days
-            "weekdays": 86400,  # Daily but only weekdays
-            "weekends": 86400,  # Daily but only weekends
-            "business_hours": 3600,  # Hourly during business hours
-        }
-
-        if expr in named_intervals:
-            return cls(expression=expression, interval_seconds=named_intervals[expr])
-
-        raise ValueError(f"Unsupported schedule expression: {expression}")
-
-
-class ScheduledTask(BaseModel):
-    """Pydantic model for scheduled task configuration."""
-
-    model_config = ConfigDict(
-        validate_assignment=True, extra="forbid", arbitrary_types_allowed=True
-    )
-
-    task_id: str = Field(..., description="Unique task identifier")
-    name: str = Field(..., description="Human-readable task name")
-    func: Callable = Field(..., description="Async function to execute")
-    schedule: ScheduleExpression = Field(..., description="Schedule expression")
-
-    # Optional configuration
-    enabled: bool = Field(default=True, description="Whether task is enabled")
-    max_runs: Optional[int] = Field(default=None, ge=1, description="Maximum number of runs")
-    timeout: int = Field(default=300, ge=1, description="Task timeout in seconds")
-    retry_attempts: int = Field(default=3, ge=0, description="Number of retry attempts")
-    retry_delay: float = Field(default=1.0, ge=0, description="Delay between retries")
-
-    # Runtime tracking
-    status: ScheduledTaskStatus = Field(default=ScheduledTaskStatus.PENDING)
-    runs_count: int = Field(default=0, ge=0, description="Number of completed runs")
-    last_run: Optional[datetime] = Field(default=None, description="Last execution time")
-    next_run: Optional[datetime] = Field(default=None, description="Next scheduled execution")
-    last_duration: Optional[float] = Field(default=None, description="Last execution duration")
-    last_error: Optional[str] = Field(default=None, description="Last error message")
-
-
-class SchedulerService:
-    """
-    📅 Scheduler Service - Enterprise Task Scheduling
-
-    Human-readable scheduling with monitoring and enterprise features:
-    - Natural language intervals ("30m", "1h", "daily")
-    - Smart load balancing with jitter
-    - Error recovery and retries
-    - Health monitoring and alerting
-    - Production-ready reliability
-    """
-
-    def __init__(
-        self, config: SchedulerConfig, logger: Optional[Any] = None, metrics: Optional[Any] = None
-    ):
-        """Initialize scheduler service."""
-        self.config = config
-        self.logger = logger
-        self.metrics = metrics
-
-        # ✅ DEVELOPMENT LOGGER INTEGRATION (CRITICAL REQUIREMENT)
-        self.dev_logger = get_development_logger()
-
-        # Scheduler state
-        self._tasks: Dict[str, ScheduledTask] = {}
-        self._running_tasks: Dict[str, asyncio.Task] = {}
-        self._is_running = False
-        self._shutdown_event = asyncio.Event()
-
-        # Configuration - SchedulerConfig is a Pydantic object
-        self.max_concurrent = config.max_concurrent_tasks
-        self.enable_jitter = config.enable_jitter
-        self.jitter_range = config.jitter_range
-
-        # Log initialization with development logger
-        if self.dev_logger:
-            self.dev_logger.log_info(
-                SDKEventType.COMPONENT_CREATED,
-                "Scheduler service initialized",
-                context=SDKContext(
-                    parser_id=self.config.parser_id,
-                    component_name="Scheduler",
-                    layer_name="UnrealOn_Driver",
-                    metadata={
-                        "max_concurrent": self.max_concurrent,
-                        "enable_jitter": self.enable_jitter,
-                    },
-                ),
-            )
-
-    def add_task(
-        self, task_id: str, name: str, func: Callable, every: str, **kwargs
-    ) -> ScheduledTask:
-        """
-        Add a new scheduled task.
-
-        Args:
-            task_id: Unique task identifier
-            name: Human-readable task name
-            func: Async function to execute
-            every: Schedule expression ("30m", "1h", "daily", etc.)
-            **kwargs: Additional task configuration
-
-        Returns:
-            Created ScheduledTask
-
-        Example:
-            scheduler.add_task(
-                "parse_news",
-                "Parse News Data",
-                my_parse_function,
-                every="30m",
-                max_runs=100,
-                timeout=60
-            )
-        """
-        try:
-            # Parse schedule expression
-            schedule = ScheduleExpression.parse(every)
-
-            # Create task
-            task = ScheduledTask(task_id=task_id, name=name, func=func, schedule=schedule, **kwargs)
-
-            # Calculate next run time
-            task.next_run = self._calculate_next_run(task)
-
-            # Store task
-            self._tasks[task_id] = task
-
-            if self.logger:
-                self.logger.info(f"📅 Added scheduled task: {name} (every {every})")
-
-            return task
-
-        except Exception as e:
-            raise SchedulingError(f"Failed to add task {task_id}: {e}", schedule_expression=every)
-
-    def remove_task(self, task_id: str) -> bool:
-        """Remove a scheduled task."""
-        if task_id in self._tasks:
-            # Cancel running task if any
-            if task_id in self._running_tasks:
-                self._running_tasks[task_id].cancel()
-                del self._running_tasks[task_id]
-
-            # Remove from schedule
-            del self._tasks[task_id]
-
-            if self.logger:
-                self.logger.info(f"📅 Removed scheduled task: {task_id}")
-
-            return True
-
-        return False
-
-    async def start(self):
-        """Start the scheduler."""
-        if self._is_running:
-            if self.logger:
-                self.logger.warning("Scheduler already running")
-            return
-
-        self._is_running = True
-        self._shutdown_event.clear()
-
-        if self.logger:
-            self.logger.info(f"📅 Starting scheduler with {len(self._tasks)} tasks")
-
-        try:
-            # Main scheduler loop
-            while self._is_running:
-                await self._scheduler_tick()
-                await asyncio.sleep(1)  # Check every second
-
-        except asyncio.CancelledError:
-            if self.logger:
-                self.logger.info("📅 Scheduler cancelled")
-        except Exception as e:
-            if self.logger:
-                self.logger.error(f"❌ Scheduler error: {e}")
-            raise
-        finally:
-            await self._cleanup_running_tasks()
-
-    async def stop(self):
-        """Stop the scheduler gracefully."""
-        if not self._is_running:
-            return
-
-        if self.logger:
-            self.logger.info("📅 Stopping scheduler...")
-
-        self._is_running = False
-        self._shutdown_event.set()
-
-        # Wait for running tasks to complete
-        await self._cleanup_running_tasks()
-
-        if self.logger:
-            self.logger.info("✅ Scheduler stopped")
-
-    async def _scheduler_tick(self):
-        """Single scheduler tick - check and execute due tasks."""
-        now = datetime.now()
-
-        # Find tasks that are due
-        due_tasks = [
-            task
-            for task in self._tasks.values()
-            if (
-                task.enabled
-                and task.next_run
-                and task.next_run <= now
-                and task.task_id not in self._running_tasks
-                and (task.max_runs is None or task.runs_count < task.max_runs)
-            )
-        ]
-
-        # Check concurrent task limit
-        available_slots = self.max_concurrent - len(self._running_tasks)
-        due_tasks = due_tasks[:available_slots]
-
-        # Execute due tasks
-        for task in due_tasks:
-            await self._execute_task(task)
-
-    async def _execute_task(self, task: ScheduledTask):
-        """Execute a scheduled task."""
-        if self.logger:
-            self.logger.info(f"🚀 Executing task: {task.name}")
-
-        # Create execution coroutine
-        execution_coro = self._run_task_with_monitoring(task)
-
-        # Start task
-        task_handle = asyncio.create_task(execution_coro)
-        self._running_tasks[task.task_id] = task_handle
-
-        # Update task status
-        task.status = ScheduledTaskStatus.RUNNING
-        task.last_run = datetime.now()
-
-    async def _run_task_with_monitoring(self, task: ScheduledTask):
-        """Run task with full monitoring and error handling."""
-        start_time = time.time()
-
-        try:
-            # Execute with timeout
-            await asyncio.wait_for(task.func(), timeout=task.timeout)
-
-            # Task completed successfully
-            duration = time.time() - start_time
-            task.status = ScheduledTaskStatus.COMPLETED
-            task.runs_count += 1
-            task.last_duration = duration
-            task.last_error = None
-
-            # Calculate next run
-            task.next_run = self._calculate_next_run(task)
-
-            if self.logger:
-                self.logger.info(f"✅ Task completed: {task.name} ({duration:.2f}s)")
-
-            # Record metrics
-            if self.metrics:
-                self.metrics.record_operation(
-                    service="scheduler",
-                    operation="task_execution",
-                    duration=duration,
-                    result_count=1,
-                )
-
-        except asyncio.TimeoutError:
-            duration = time.time() - start_time
-            error_msg = f"Task timeout after {duration:.2f}s"
-
-            task.status = ScheduledTaskStatus.FAILED
-            task.last_duration = duration
-            task.last_error = error_msg
-
-            if self.logger:
-                self.logger.error(f"⏰ Task timeout: {task.name}")
-
-            await self._handle_task_failure(task, error_msg)
-
-        except Exception as e:
-            duration = time.time() - start_time
-            error_msg = str(e)
-
-            task.status = ScheduledTaskStatus.FAILED
-            task.last_duration = duration
-            task.last_error = error_msg
-
-            if self.logger:
-                self.logger.error(f"❌ Task failed: {task.name} - {error_msg}")
-
-            await self._handle_task_failure(task, error_msg)
-
-        finally:
-            # Remove from running tasks
-            if task.task_id in self._running_tasks:
-                del self._running_tasks[task.task_id]
-
-    async def _handle_task_failure(self, task: ScheduledTask, error_msg: str):
-        """Handle task failure with retry logic."""
-        # TODO: Implement retry logic if needed
-        # Calculate next run even for failed tasks
-        task.next_run = self._calculate_next_run(task)
-
-        # Record error metrics
-        if self.metrics:
-            self.metrics.record_operation(
-                service="scheduler",
-                operation="task_execution",
-                duration=task.last_duration or 0,
-                result_count=0,
-                error=error_msg,
-            )
-
-    def _calculate_next_run(self, task: ScheduledTask) -> datetime:
-        """Calculate next run time for a task."""
-        now = datetime.now()
-        base_next = now + timedelta(seconds=task.schedule.interval_seconds)
-
-        # Apply jitter if enabled
-        if self.enable_jitter:
-            jitter_seconds = task.schedule.interval_seconds * self.jitter_range
-            import random
-
-            jitter = random.uniform(-jitter_seconds, jitter_seconds)
-            base_next += timedelta(seconds=jitter)
-
-        return base_next
-
-    async def _cleanup_running_tasks(self):
-        """Clean up running tasks during shutdown."""
-        if not self._running_tasks:
-            return
-
-        if self.logger:
-            self.logger.info(f"🧹 Cleaning up {len(self._running_tasks)} running tasks...")
-
-        # Cancel all running tasks
-        for task_id, task_handle in self._running_tasks.items():
-            task_handle.cancel()
-
-        # Wait for cancellation
-        if self._running_tasks:
-            await asyncio.gather(*self._running_tasks.values(), return_exceptions=True)
-
-        self._running_tasks.clear()
-
-    # ==========================================
-    # STATUS AND MONITORING
-    # ==========================================
-
-    def get_task_status(self, task_id: str) -> Optional[dict]:
-        """Get status of a specific task."""
-        if task_id not in self._tasks:
-            return None
-
-        task = self._tasks[task_id]
-        return {
-            "task_id": task.task_id,
-            "name": task.name,
-            "status": task.status.value,
-            "enabled": task.enabled,
-            "runs_count": task.runs_count,
-            "last_run": task.last_run.isoformat() if task.last_run else None,
-            "next_run": task.next_run.isoformat() if task.next_run else None,
-            "last_duration": task.last_duration,
-            "last_error": task.last_error,
-            "schedule": task.schedule.expression,
-            "interval_seconds": task.schedule.interval_seconds,
-        }
-
-    def get_all_tasks_status(self) -> dict:
-        """Get status of all tasks."""
-        return {task_id: self.get_task_status(task_id) for task_id in self._tasks}
-
-    async def health_check(self) -> dict:
-        """Check scheduler service health."""
-        return {
-            "status": "healthy" if self._is_running else "stopped",
-            "is_running": self._is_running,
-            "total_tasks": len(self._tasks),
-            "enabled_tasks": sum(1 for t in self._tasks.values() if t.enabled),
-            "running_tasks": len(self._running_tasks),
-            "max_concurrent": self.max_concurrent,
-            "tasks": self.get_all_tasks_status(),
-        }
-
-    async def cleanup(self):
-        """Clean up scheduler resources."""
-        await self.stop()
-        self._tasks.clear()
-
-        if self.logger:
-            self.logger.info("Scheduler service cleanup completed")
-
-    def __repr__(self) -> str:
-        return f"<SchedulerService(running={self._is_running}, tasks={len(self._tasks)})>"