Update app.py

app.py

@@ -16,50 +16,50 @@ pinger_spaces = [
     "https://rajhuggingface4253-ping2.hf.space",
 ]
 
-# Regular servers to ping
+# Regular servers to ping (HTTP GET)
 regular_servers = [
     "https://rajhuggingface4253-backend-compressorpro.hf.space",
     "https://rajhuggingface4253-backend-compressorpro2.hf.space",
     "https://rajhuggingface4253-compressor3pro.hf.space"
 ]
 
-# Chat models that need warmup messages
-chat_models = [
+# Models to warm using health endpoints
+models_to_warm = [
     {
+        "name": "Qwen 1",
         "url": "https://rajhuggingface4253-qwen.hf.space",
-        "api_endpoint": "/chat",  # Adjust based on your API
-        "warmup_message": "Say 'active' in one word?",
-        "type": "qwen"
+        "endpoint": "/health",
+        "type": "health_check"
     },
     {
-        "url": "https://rajhuggingface4253-qwen2.hf.space", 
-        "api_endpoint": "/chat",
-        "warmup_message": "Say 'active' in one word",
-        "type": "qwen2"
+        "name": "Qwen 2", 
+        "url": "https://rajhuggingface4253-qwen2.hf.space",
+        "endpoint": "/health",
+        "type": "health_check"
     },
     {
+        "name": "Qwen 3",
         "url": "https://rajhuggingface4253-qwen3.hf.space",
-        "api_endpoint": "/chat",
-        "warmup_message": "Just say OK",
-        "type": "qwen3"
+        "endpoint": "/health",
+        "type": "health_check"
     },
     {
-        "url": "https://rajhuggingface4253-koko.hf.space",
-        "api_endpoint": "/tts",
-        "warmup_message": "Active",
-        "type": "tts"
+        "name": "Kokoro TTS",
+        "url": "https://rajhuggingface4253-koko.hf.space", 
+        "endpoint": "/health",  # Assuming it has a health endpoint
+        "type": "health_check"
     }
 ]
 
 # Global state
 ping_results: Dict[str, Dict] = {}
-chat_warmup_results: Dict[str, Dict] = {}
+model_warmup_results: Dict[str, Dict] = {}
 health_results: Dict[str, Dict] = {}
 last_ping_run: datetime = None
-last_chat_warmup: datetime = None
+last_model_warmup: datetime = None
 
 async def ping_server(url: str) -> Dict:
-    """Ping a regular server"""
+    """Ping a regular server with HTTP GET"""
     try:
         start_time = time.time()
         async with httpx.AsyncClient(timeout=10.0) as client:
@@ -79,43 +79,65 @@ async def ping_server(url: str) -> Dict:
             'timestamp': datetime.now().isoformat()
         }
 
-async def warmup_chat_model(model_config: Dict) -> Dict:
-    """Send a warmup message to a chat model"""
+async def warmup_model_health(model_config: Dict) -> Dict:
+    """Warm up a model by calling its health endpoint"""
     try:
         start_time = time.time()
-        async with httpx.AsyncClient(timeout=30.0) as client:
-            if model_config["type"].startswith("qwen"):
-                payload = {
-                    "message": model_config["warmup_message"],
-                    "max_tokens": 10
-                }
-            else:
-                payload = {
-                    "messages": [{"role": "user", "content": model_config["warmup_message"]}],
-                    "max_tokens": 10
-                }
-            
-            api_url = f"{model_config['url']}{model_config['api_endpoint']}"
-            response = await client.post(
-                api_url,
-                json=payload,
-                headers={"Content-Type": "application/json"}
-            )
+        async with httpx.AsyncClient(timeout=15.0) as client:
             
+            api_url = f"{model_config['url']}{model_config['endpoint']}"
+            response = await client.get(api_url)
             response_time = round((time.time() - start_time) * 1000, 1)
             
-            return {
-                'status': 'success',
-                'response_time_ms': response_time,
-                'status_code': response.status_code,
-                'response_preview': str(response.text)[:100],
-                'timestamp': datetime.now().isoformat()
-            }
-            
+            # Check if health endpoint returned successful status
+            if response.status_code == 200:
+                try:
+                    # Try to parse JSON response
+                    health_data = response.json()
+                    model_status = health_data.get('status', 'unknown')
+                    model_name = health_data.get('model', 'Unknown')
+                    
+                    is_healthy = model_status in ['ok', 'healthy', 'ready']
+                    
+                    return {
+                        'status': 'success' if is_healthy else 'error',
+                        'response_time_ms': response_time,
+                        'status_code': response.status_code,
+                        'model_status': model_status,
+                        'model_name': model_name,
+                        'got_response': True,
+                        'timestamp': datetime.now().isoformat()
+                    }
+                except:
+                    # If JSON parsing fails but status is 200, consider it successful
+                    return {
+                        'status': 'success',
+                        'response_time_ms': response_time,
+                        'status_code': response.status_code,
+                        'model_status': 'ok',
+                        'model_name': 'Unknown',
+                        'got_response': True,
+                        'timestamp': datetime.now().isoformat()
+                    }
+            else:
+                return {
+                    'status': 'error',
+                    'response_time_ms': response_time,
+                    'status_code': response.status_code,
+                    'model_status': 'unhealthy',
+                    'model_name': 'Unknown',
+                    'got_response': False,
+                    'timestamp': datetime.now().isoformat()
+                }
+                
     except Exception as e:
         return {
             'status': 'error',
             'error': str(e),
+            'response_time_ms': round((time.time() - start_time) * 1000, 1),
+            'model_status': 'connection_failed',
+            'model_name': 'Unknown',
+            'got_response': False,
             'timestamp': datetime.now().isoformat()
         }
 
@@ -139,23 +161,34 @@ async def ping_all_servers():
     
     return results
 
-async def warmup_all_chat_models():
-    """Warm up all chat models with actual messages"""
-    global chat_warmup_results, last_chat_warmup
+async def warmup_all_models():
+    """Warm up all models using health endpoints"""
+    global model_warmup_results, last_model_warmup
     
-    if not chat_models:
+    if not models_to_warm:
         return []
     
-    tasks = [warmup_chat_model(model) for model in chat_models]
+    tasks = [warmup_model_health(model) for model in models_to_warm]
     results = await asyncio.gather(*tasks)
     
-    for i, model in enumerate(chat_models):
-        chat_warmup_results[model['url']] = results[i]
+    for i, model in enumerate(models_to_warm):
+        model_warmup_results[model['url']] = {
+            'model_info': model,
+            'health_check': results[i]
+        }
+        
+        # Log detailed results
+        result = results[i]
+        if result['status'] == 'success' and result.get('got_response'):
+            print(f"✅ {model['name']}: {result['response_time_ms']}ms - {result['model_name']} ({result['model_status']})")
+        else:
+            print(f"❌ {model['name']}: {result.get('error', 'Health check failed')}")
     
-    last_chat_warmup = datetime.now()
+    last_model_warmup = datetime.now()
     
+    # Count as success only if health check passed
     success_count = sum(1 for result in results if result['status'] == 'success')
-    print(f"🤖 {datetime.now().strftime('%H:%M:%S')} - Chat models: {success_count}/{len(chat_models)} Warmed up")
+    print(f"🤖 {datetime.now().strftime('%H:%M:%S')} - Models: {success_count}/{len(models_to_warm)} Healthy")
     
     return results
 
@@ -184,20 +217,22 @@ async def ping_single_health(client: httpx.AsyncClient, space_url: str, health_u
             'status_code': response.status_code,
             'last_ping': datetime.now().isoformat()
         }
+        print(f"🔗 Health ping to {space_url}: {response_time}ms")
     except Exception as e:
         health_results[space_url] = {
             'status': 'error',
             'error': str(e),
             'last_ping': datetime.now().isoformat()
         }
+        print(f"🔗 Health ping failed for {space_url}: {e}")
 
 async def continuous_pinging():
-    """Main pinging loop with chat model warming"""
-    print("🚀 Chat Model Warmer Started!")
+    """Main pinging loop with model health checking"""
+    print("🚀 Smart Model Warmer Started!")
     print(f"🌐 Regular servers: {len(regular_servers)}")
-    print(f"🤖 Chat models: {len(chat_models)}")
+    print(f"🤖 Models to warm: {len(models_to_warm)}")
     print(f"🔗 Pinger network: {len(pinger_spaces)}")
-    print("⏰ Chat warmup every 5 minutes")
+    print("⏰ Health checks every 5 minutes")
     
     last_health_check = 0
     
@@ -207,49 +242,100 @@ async def continuous_pinging():
             if regular_servers:
                 await ping_all_servers()
             
-            # Warm up chat models (most important!)
-            if chat_models:
-                await warmup_all_chat_models()
+            # Warm up models using health endpoints
+            if models_to_warm:
+                await warmup_all_models()
             
-            # Ping health endpoints every 30 minutes (FIXED: use the defined constant)
+            # Ping health endpoints every 30 minutes
             current_time = time.time()
             if current_time - last_health_check >= HEALTH_CHECK_INTERVAL and pinger_spaces:
+                print("🔄 Pinging other pinger spaces...")
                 await ping_health_endpoints()
                 last_health_check = current_time
             
             await asyncio.sleep(PING_INTERVAL)
             
         except Exception as e:
-            print(f"❌ Error: {e}")
+            print(f"❌ Error in main loop: {e}")
             await asyncio.sleep(60)
 
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     # Startup
-    print("Starting up Chat Model Warmer...")
+    print("Starting up Smart Model Warmer...")
     asyncio.create_task(continuous_pinging())
     yield
     # Shutdown
     print("Shutting down...")
 
-app = FastAPI(title="Chat Model Warmer", lifespan=lifespan)
+app = FastAPI(title="Smart Model Warmer", lifespan=lifespan)
 
 @app.get("/", response_class=HTMLResponse)
 async def home():
-    """Minimal dashboard"""
+    """Dashboard showing warming status"""
     regular_success = sum(1 for r in ping_results.values() if r.get('status') == 'success')
-    chat_success = sum(1 for r in chat_warmup_results.values() if r.get('status') == 'success')
+    model_success = sum(1 for r in model_warmup_results.values() if r['health_check'].get('status') == 'success')
     health_success = sum(1 for r in health_results.values() if r.get('status') == 'success')
     
+    # Get model details for display
+    model_statuses = []
+    for url, data in model_warmup_results.items():
+        model_info = data['model_info']
+        health = data['health_check']
+        model_statuses.append({
+            'name': model_info['name'],
+            'status': health['status'],
+            'response_time': health.get('response_time_ms', 0),
+            'model_name': health.get('model_name', 'Unknown')
+        })
+    
+    model_status_html = "".join([
+        f"<li>{m['name']}: <span class={'success' if m['status'] == 'success' else 'error'}>{m['status']}</span> "
+        f"({m['response_time']}ms) - {m['model_name']}</li>" 
+        for m in model_statuses
+    ])
+    
     html_content = f"""
     <html>
-        <head><title>Chat Model Warmer</title></head>
+        <head>
+            <title>Smart Model Warmer</title>
+            <style>
+                body {{ font-family: Arial, sans-serif; margin: 40px; }}
+                .success {{ color: green; font-weight: bold; }}
+                .error {{ color: red; font-weight: bold; }}
+                .container {{ max-width: 1000px; margin: 0 auto; }}
+                .model-list {{ background: #f5f5f5; padding: 15px; border-radius: 5px; }}
+            </style>
+        </head>
         <body>
-            <h1>🤖 Chat Model Warmer</h1>
-            <p><strong>Regular Servers:</strong> {regular_success}/{len(regular_servers)} OK</p>
-            <p><strong>Chat Models:</strong> {chat_success}/{len(chat_models)} Warmed up</p>
-            <p><strong>Last Chat Warmup:</strong> {last_chat_warmup.strftime('%H:%M:%S') if last_chat_warmup else 'Never'}</p>
-            <p><strong>Network:</strong> {health_success}/{len(pinger_spaces)} OK</p>
+            <div class="container">
+                <h1>🤖 Smart Model Warmer</h1>
+                
+                <div style="display: grid; grid-template-columns: 1fr 1fr 1fr; gap: 20px; margin-bottom: 30px;">
+                    <div style="background: #e8f5e8; padding: 15px; border-radius: 8px;">
+                        <h3>🌐 Regular Servers</h3>
+                        <p><strong>{regular_success}/{len(regular_servers)} OK</strong></p>
+                    </div>
+                    <div style="background: #e3f2fd; padding: 15px; border-radius: 8px;">
+                        <h3>🤖 AI Models</h3>
+                        <p><strong>{model_success}/{len(models_to_warm)} Healthy</strong></p>
+                    </div>
+                    <div style="background: #fff3e0; padding: 15px; border-radius: 8px;">
+                        <h3>🔗 Pinger Network</h3>
+                        <p><strong>{health_success}/{len(pinger_spaces)} OK</strong></p>
+                    </div>
+                </div>
+                
+                <div class="model-list">
+                    <h3>Model Health Status</h3>
+                    <ul>
+                        {model_status_html if model_statuses else "<li>No model data yet</li>"}
+                    </ul>
+                </div>
+                
+                <p><strong>Last Model Check:</strong> {last_model_warmup.strftime('%Y-%m-%d %H:%M:%S') if last_model_warmup else 'Never'}</p>
+                <p><strong>Next check in:</strong> ~5 minutes</p>
+            </div>
         </body>
     </html>
     """
@@ -257,19 +343,35 @@ async def home():
 
 @app.get("/health")
 async def health():
+    """Health endpoint for other pingers"""
     return JSONResponse({
         "status": "healthy",
-        "service": "chat-model-warmer",
+        "service": "smart-model-warmer",
         "regular_servers": len(regular_servers),
-        "chat_models": len(chat_models),
-        "last_chat_warmup": last_chat_warmup.isoformat() if last_chat_warmup else None
+        "ai_models": len(models_to_warm),
+        "last_model_warmup": last_model_warmup.isoformat() if last_model_warmup else None,
+        "timestamp": datetime.now().isoformat()
     })
 
 @app.get("/status")
 async def status():
+    """Detailed status endpoint"""
     return JSONResponse({
         "regular_servers": ping_results,
-        "chat_models": chat_warmup_results,
+        "ai_models": model_warmup_results,
+        "pinger_network": health_results,
+        "timestamp": datetime.now().isoformat()
+    })
+
+@app.get("/ping-now")
+async def ping_now():
+    """Manually trigger immediate warming"""
+    results = await warmup_all_models()
+    success_count = sum(1 for result in results if result['status'] == 'success')
+    
+    return JSONResponse({
+        "message": "Manual warming completed",
+        "models_healthy": f"{success_count}/{len(models_to_warm)}",
         "timestamp": datetime.now().isoformat()
     })