llm_startup.py

"""
Flare – LLM startup notifier (Refactored)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Projeler açılırken LLM provider'a startup çağrısı yapar.
"""

from __future__ import annotations
import threading
import asyncio
from typing import Dict, Any
from logger import log_info, log_error, log_warning, log_debug
from config_provider import ConfigProvider, ProjectConfig, VersionConfig
from llm_factory import LLMFactory

def _select_live_version(p: ProjectConfig) -> VersionConfig | None:
    """Yayınlanmış en güncel versiyonu getir."""
    published = [v for v in p.versions if v.published]
    return max(published, key=lambda v: v.no) if published else None

async def notify_startup_async():
    """Notify LLM provider about project startups (async version)"""
    cfg = ConfigProvider.get()
    
    # Check if LLM provider requires repo info
    llm_provider_def = cfg.global_config.get_provider_config(
        "llm", 
        cfg.global_config.llm_provider.name
    )
    
    if not llm_provider_def or not llm_provider_def.requires_repo_info:
        log_info(f"ℹ️ LLM provider '{cfg.global_config.llm_provider.name}' does not require startup notification")
        return
    
    # Create LLM provider instance
    try:
        llm_provider = LLMFactory.create_provider()
    except Exception as e:
        log_error("❌ Failed to create LLM provider for startup", e)
        return
    
    # Notify for each enabled project
    enabled_projects = [p for p in cfg.projects if p.enabled and not getattr(p, 'deleted', False)]
    
    if not enabled_projects:
        log_info("ℹ️ No enabled projects found for startup notification")
        return
    
    for project in enabled_projects:
        version = _select_live_version(project)
        if not version:
            log_info(f"⚠️ No published version found for project '{project.name}', skipping startup")
            continue
        
        # Build project config - version.id yerine version.no kullan
        project_config = {
            "name": project.name,
            "version_no": version.no,  # version_id yerine version_no
            "repo_id": version.llm.repo_id,
            "generation_config": version.llm.generation_config,
            "use_fine_tune": version.llm.use_fine_tune,
            "fine_tune_zip": version.llm.fine_tune_zip
        }
        
        try:
            log_info(f"🚀 Notifying LLM provider startup for project '{project.name}'...")
            success = await llm_provider.startup(project_config)
            
            if success:
                log_info(f"✅ LLM provider acknowledged startup for '{project.name}'")
            else:
                log_info(f"⚠️ LLM provider startup failed for '{project.name}'")
                
        except Exception as e:
            log_error(f"❌ Error during startup notification for '{project.name}'", e)

def notify_startup():
    """Synchronous wrapper for async startup notification"""
    # Create new event loop for thread
    loop = asyncio.new_event_loop()
    asyncio.set_event_loop(loop)
    
    try:
        loop.run_until_complete(notify_startup_async())
    finally:
        loop.close()

def run_in_thread():
    """Start startup notification in background thread"""
    cfg = ConfigProvider.get()
    
    # Check if provider requires startup
    llm_provider_def = cfg.global_config.get_provider_config(
        "llm", 
        cfg.global_config.llm_provider.name
    )
    
    if not llm_provider_def or not llm_provider_def.requires_repo_info:
        log_info(f"🤖 {cfg.global_config.llm_provider.name} - Startup notification not required")
        return
    
    log_info("🚀 Starting LLM provider startup notification thread...")
    threading.Thread(target=notify_startup, daemon=True).start()