Scheduled research persona generation

backend/services/scheduler/core/interval_manager.py

@@ -0,0 +1,139 @@
+"""
+Interval Manager
+Handles intelligent scheduling interval adjustment based on active strategies.
+"""
+
+from typing import TYPE_CHECKING
+from datetime import datetime
+from sqlalchemy.orm import Session
+
+from services.database import get_db_session
+from utils.logger_utils import get_service_logger
+from models.scheduler_models import SchedulerEventLog
+
+if TYPE_CHECKING:
+    from .scheduler import TaskScheduler
+
+logger = get_service_logger("interval_manager")
+
+
+async def determine_optimal_interval(
+    scheduler: 'TaskScheduler',
+    min_interval: int,
+    max_interval: int
+) -> int:
+    """
+    Determine optimal check interval based on active strategies.
+    
+    Args:
+        scheduler: TaskScheduler instance
+        min_interval: Minimum check interval in minutes
+        max_interval: Maximum check interval in minutes
+        
+    Returns:
+        Optimal check interval in minutes
+    """
+    db = None
+    try:
+        db = get_db_session()
+        if db:
+            from services.active_strategy_service import ActiveStrategyService
+            active_strategy_service = ActiveStrategyService(db_session=db)
+            active_count = active_strategy_service.count_active_strategies_with_tasks()
+            scheduler.stats['active_strategies_count'] = active_count
+            
+            if active_count > 0:
+                logger.info(f"Found {active_count} active strategies with tasks - using {min_interval}min interval")
+                return min_interval
+            else:
+                logger.info(f"No active strategies with tasks - using {max_interval}min interval")
+                return max_interval
+    except Exception as e:
+        logger.warning(f"Error determining optimal interval: {e}, using default {min_interval}min")
+    finally:
+        if db:
+            db.close()
+    
+    # Default to shorter interval on error (safer)
+    return min_interval
+
+
+async def adjust_check_interval_if_needed(
+    scheduler: 'TaskScheduler',
+    db: Session
+):
+    """
+    Intelligently adjust check interval based on active strategies.
+    
+    If there are active strategies with tasks, check more frequently.
+    If there are no active strategies, check less frequently.
+    
+    Args:
+        scheduler: TaskScheduler instance
+        db: Database session
+    """
+    try:
+        from services.active_strategy_service import ActiveStrategyService
+        
+        active_strategy_service = ActiveStrategyService(db_session=db)
+        active_count = active_strategy_service.count_active_strategies_with_tasks()
+        scheduler.stats['active_strategies_count'] = active_count
+        
+        # Determine optimal interval
+        if active_count > 0:
+            optimal_interval = scheduler.min_check_interval_minutes
+        else:
+            optimal_interval = scheduler.max_check_interval_minutes
+        
+        # Only reschedule if interval needs to change
+        if optimal_interval != scheduler.current_check_interval_minutes:
+            interval_message = (
+                f"[Scheduler] ⚙️ Adjusting Check Interval\n"
+                f"   ├─ Current: {scheduler.current_check_interval_minutes}min\n"
+                f"   ├─ Optimal: {optimal_interval}min\n"
+                f"   ├─ Active Strategies: {active_count}\n"
+                f"   └─ Reason: {'Active strategies detected' if active_count > 0 else 'No active strategies'}"
+            )
+            logger.warning(interval_message)
+            
+            # Reschedule the job with new interval
+            scheduler.scheduler.modify_job(
+                'check_due_tasks',
+                trigger=scheduler._get_trigger_for_interval(optimal_interval)
+            )
+            
+            # Save previous interval before updating
+            previous_interval = scheduler.current_check_interval_minutes
+            
+            # Update current interval
+            scheduler.current_check_interval_minutes = optimal_interval
+            scheduler.stats['last_interval_adjustment'] = datetime.utcnow().isoformat()
+            
+            # Save interval adjustment event to database
+            try:
+                event_db = get_db_session()
+                if event_db:
+                    event_log = SchedulerEventLog(
+                        event_type='interval_adjustment',
+                        event_date=datetime.utcnow(),
+                        previous_interval_minutes=previous_interval,
+                        new_interval_minutes=optimal_interval,
+                        check_interval_minutes=optimal_interval,
+                        active_strategies_count=active_count,
+                        event_data={
+                            'reason': 'intelligent_scheduling',
+                            'min_interval': scheduler.min_check_interval_minutes,
+                            'max_interval': scheduler.max_check_interval_minutes
+                        }
+                    )
+                    event_db.add(event_log)
+                    event_db.commit()
+                    event_db.close()
+            except Exception as e:
+                logger.warning(f"Failed to save interval adjustment event log: {e}")
+            
+            logger.warning(f"[Scheduler] ✅ Interval adjusted to {optimal_interval}min")
+        
+    except Exception as e:
+        logger.warning(f"Error adjusting check interval: {e}")
+