Rename spark_startup.py to llm_startup.py

llm_startup.py

@@ -0,0 +1,102 @@
+"""
+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 utils import log
+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.id) 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(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(f"❌ 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("ℹ️ No enabled projects found for startup notification")
+        return
+    
+    for project in enabled_projects:
+        version = _select_live_version(project)
+        if not version:
+            log(f"⚠️ No published version found for project '{project.name}', skipping startup")
+            continue
+        
+        # Build project config
+        project_config = {
+            "name": project.name,
+            "version_id": version.id,
+            "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(f"🚀 Notifying LLM provider startup for project '{project.name}'...")
+            success = await llm_provider.startup(project_config)
+            
+            if success:
+                log(f"✅ LLM provider acknowledged startup for '{project.name}'")
+            else:
+                log(f"⚠️ LLM provider startup failed for '{project.name}'")
+                
+        except Exception as e:
+            log(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(f"🤖 {cfg.global_config.llm_provider.name} - Startup notification not required")
+        return
+    
+    log("🚀 Starting LLM provider startup notification thread...")
+    threading.Thread(target=notify_startup, daemon=True).start()

spark_startup.py

@@ -1,106 +0,0 @@
-"""
-Flare – LLM startup notifier
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-Projeler açılırken LLM provider'a startup çağrısı yapar.
-"""
-
-from __future__ import annotations
-import threading, requests, os
-from typing import Dict, Any
-from utils import log
-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.id) if published else None
-
-def notify_startup():
-    """Notify LLM provider about project startups"""
-    cfg = ConfigProvider.get()
-    
-    # Check if current provider needs startup notification
-    llm_config = cfg.global_config.llm_provider
-    if not llm_config:
-        log("⚠️ No LLM provider configured")
-        return
-    
-    provider_def = cfg.global_config.get_provider_config("llm", llm_config.name)
-    if not provider_def:
-        log(f"⚠️ Unknown LLM provider: {llm_config.name}")
-        return
-    
-    # Currently only Spark variants need startup
-    if llm_config.name not in ("spark", "spark_cloud", "spark_onpremise"):
-        log(f"ℹ️ {llm_config.name} doesn't require startup notification")
-        return
-    
-    # Check if provider requires repo info
-    if not provider_def.requires_repo_info:
-        log(f"ℹ️ {llm_config.name} doesn't require repo info for startup")
-        return
-    
-    # Get endpoint and API key
-    endpoint = llm_config.endpoint
-    if not endpoint:
-        log("⚠️ No LLM endpoint configured for startup")
-        return
-    
-    api_key = cfg.global_config.get_plain_api_key("llm")
-    if not api_key:
-        # Try environment
-        env_var = "SPARK_TOKEN"
-        if os.environ.get("SPACE_ID"):
-            api_key = os.environ.get(env_var)
-        else:
-            from dotenv import load_dotenv
-            load_dotenv()
-            api_key = os.getenv(env_var)
-        
-        if not api_key:
-            log("⚠️ No API key available for startup")
-            return
-    
-    spark_base = str(endpoint).rstrip("/")
-
-    for p in cfg.projects:
-        if not p.enabled:
-            continue
-        v = _select_live_version(p)
-        if not v:
-            continue
-        
-        # Check if version has LLM config (required for Spark)
-        if not v.llm:
-            log(f"⚠️ No LLM config in version {v.id} for project '{p.name}'")
-            continue
-
-        body: Dict[str, Any] = {
-            # Required fields for Spark startup
-            "project_name": p.name,
-            "project_version": v.id,
-            "repo_id": v.llm.repo_id,
-            "generation_config": v.llm.generation_config,
-            "use_fine_tune": v.llm.use_fine_tune,
-            "fine_tune_zip": v.llm.fine_tune_zip,
-        }
-
-        headers = {
-            "Authorization": f"Bearer {api_key}",
-            "Content-Type": "application/json"
-        }
-
-        try:
-            log(f"🚀 Notifying {llm_config.name} /startup for project '{p.name}' …")
-            r = requests.post(f"{spark_base}/startup", json=body, headers=headers, timeout=10)
-            if r.status_code >= 400:
-                log(f"❌ LLM provider responded {r.status_code}: {r.text}")
-                r.raise_for_status()
-            log(f"✅ LLM provider acknowledged startup ({r.status_code})")
-        except Exception as e:
-            log(f"⚠️ LLM startup failed: {e}")
-
-def run_in_thread():
-    """Run startup notification in background thread"""
-    threading.Thread(target=notify_startup, daemon=True).start()