Update app.py

app.py

@@ -1,47 +1,64 @@
-from fastapi import FastAPI, HTTPException
+from fastapi import FastAPI
 from fastapi.responses import HTMLResponse, JSONResponse
 import httpx
 import asyncio
 import time
 from datetime import datetime
 from typing import Dict, List
-import os
-
-app = FastAPI(title="FastAPI Pinger", description="High-performance server warming service")
+from contextlib import asynccontextmanager
 
 # Configuration
 PING_INTERVAL = 300  # 5 minutes
 HEALTH_CHECK_INTERVAL = 1800  # 30 minutes
 
-# List of other pinger Spaces (add your Space URLs here)
+# List of other pinger Spaces
 pinger_spaces = [
-    "https://rajhuggingface4253-ping2.hf.space",
-    
+    "https://rajhuggingface4253-ping.hf.space",
 ]
 
-# Your target servers to keep warm
-target_servers = [
-    "https://rajhuggingface4253-qwen.hf.space",
-    "https://rajhuggingface4253-qwen2.hf.space", 
-    "https://rajhuggingface4253-qwen3.hf.space",
+# Regular servers to ping
+regular_servers = [
     "https://rajhuggingface4253-backend-compressorpro.hf.space",
     "https://rajhuggingface4253-backend-compressorpro2.hf.space",
     "https://rajhuggingface4253-compressor3pro.hf.space",
     "https://rajhuggingface4253-koko.hf.space"
 ]
 
+# Chat models that need warmup messages
+chat_models = [
+    {
+        "url": "https://rajhuggingface4253-qwen.hf.space",
+        "api_endpoint": "/chat",  # Adjust based on your API
+        "warmup_message": "Say 'active' in one word?",
+        "type": "qwen"
+    },
+    {
+        "url": "https://rajhuggingface4253-qwen2.hf.space", 
+        "api_endpoint": "/chat",
+        "warmup_message": "Say 'active' in one word",
+        "type": "qwen2"
+    },
+    {
+        "url": "https://rajhuggingface4253-qwen3.hf.space",
+        "api_endpoint": "/chat",
+        "warmup_message": "Just say OK",
+        "type": "qwen3"
+    }
+]
+
 # Global state
 ping_results: Dict[str, Dict] = {}
+chat_warmup_results: Dict[str, Dict] = {}
 health_results: Dict[str, Dict] = {}
 last_ping_run: datetime = None
+last_chat_warmup: datetime = None
 
 async def ping_server(url: str) -> Dict:
-    """Ping a single server asynchronously"""
+    """Ping a regular server"""
     try:
         start_time = time.time()
         async with httpx.AsyncClient(timeout=10.0) as client:
-            full_url = url if '://' in url else f'https://{url}'
-            response = await client.get(full_url)
+            response = await client.get(url)
             response_time = round((time.time() - start_time) * 1000, 1)
             
             return {
@@ -57,27 +74,88 @@ 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"""
+    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"}
+            )
+            
+            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()
+            }
+            
+    except Exception as e:
+        return {
+            'status': 'error',
+            'error': str(e),
+            'timestamp': datetime.now().isoformat()
+        }
+
 async def ping_all_servers():
-    """Ping all target servers concurrently"""
+    """Ping all regular servers"""
     global ping_results, last_ping_run
     
-    tasks = [ping_server(server) for server in target_servers]
+    if not regular_servers:
+        return []
+    
+    tasks = [ping_server(server) for server in regular_servers]
     results = await asyncio.gather(*tasks)
     
-    # Store results
-    for i, server in enumerate(target_servers):
+    for i, server in enumerate(regular_servers):
         ping_results[server] = results[i]
     
     last_ping_run = datetime.now()
     
-    # Log results
     success_count = sum(1 for result in results if result['status'] == 'success')
-    print(f"{datetime.now().strftime('%H:%M:%S')} - {success_count}/{len(target_servers)} servers OK")
+    print(f"🌐 {datetime.now().strftime('%H:%M:%S')} - Regular servers: {success_count}/{len(regular_servers)} OK")
+    
+    return results
+
+async def warmup_all_chat_models():
+    """Warm up all chat models with actual messages"""
+    global chat_warmup_results, last_chat_warmup
+    
+    if not chat_models:
+        return []
+    
+    tasks = [warmup_chat_model(model) for model in chat_models]
+    results = await asyncio.gather(*tasks)
+    
+    for i, model in enumerate(chat_models):
+        chat_warmup_results[model['url']] = results[i]
+    
+    last_chat_warmup = datetime.now()
+    
+    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")
     
     return results
 
 async def ping_health_endpoints():
-    """Ping other pinger Spaces concurrently"""
+    """Ping other pinger Spaces"""
     global health_results
     
     async with httpx.AsyncClient(timeout=10.0) as client:
@@ -101,79 +179,72 @@ 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"""
-    print("🚀 FastAPI Pinger Started!")
-    print(f"📊 Monitoring {len(target_servers)} target servers")
-    print(f"🔗 Connected to {len(pinger_spaces)} pinger spaces")
-    print(f"⏰ Pinging every {PING_INTERVAL//60} minutes")
+    """Main pinging loop with chat model warming"""
+    print("🚀 Chat Model Warmer Started!")
+    print(f"🌐 Regular servers: {len(regular_servers)}")
+    print(f"🤖 Chat models: {len(chat_models)}")
+    print(f"🔗 Pinger network: {len(pinger_spaces)}")
+    print("⏰ Chat warmup every 5 minutes")
     
     last_health_check = 0
     
     while True:
         try:
-            # Ping target servers
-            await ping_all_servers()
+            # Ping regular servers
+            if regular_servers:
+                await ping_all_servers()
+            
+            # Warm up chat models (most important!)
+            if chat_models:
+                await warmup_all_chat_models()
             
-            # Ping health endpoints every 30 minutes
+            # Ping health endpoints every 30 minutes (FIXED: use the defined constant)
             current_time = time.time()
-            if current_time - last_health_check >= HEALTH_CHECK_INTERVAL:
-                if pinger_spaces:
-                    print("🔄 Pinging other pinger spaces...")
-                    await ping_health_endpoints()
+            if current_time - last_health_check >= HEALTH_CHECK_INTERVAL and pinger_spaces:
+                await ping_health_endpoints()
                 last_health_check = current_time
             
-            # Wait for next cycle
             await asyncio.sleep(PING_INTERVAL)
             
         except Exception as e:
-            print(f"❌ Error in pinging loop: {e}")
-            await asyncio.sleep(60)  # Wait 1 minute before retrying
+            print(f"❌ Error: {e}")
+            await asyncio.sleep(60)
 
-@app.on_event("startup")
-async def startup_event():
-    """Start the pinging loop when the app starts"""
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    # Startup
+    print("Starting up Chat Model Warmer...")
     asyncio.create_task(continuous_pinging())
+    yield
+    # Shutdown
+    print("Shutting down...")
+
+app = FastAPI(title="Chat Model Warmer", lifespan=lifespan)
 
 @app.get("/", response_class=HTMLResponse)
 async def home():
-    """Main dashboard"""
-    success_count = sum(1 for result in ping_results.values() if result.get('status') == 'success')
-    health_success = sum(1 for result in health_results.values() if result.get('status') == 'success')
+    """Minimal dashboard"""
+    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')
+    health_success = sum(1 for r in health_results.values() if r.get('status') == 'success')
     
     html_content = f"""
     <html>
-        <head>
-            <title>FastAPI Pinger</title>
-            <style>
-                body {{ font-family: Arial, sans-serif; margin: 40px; }}
-                .success {{ color: green; }}
-                .error {{ color: red; }}
-                .container {{ max-width: 800px; margin: 0 auto; }}
-            </style>
-        </head>
+        <head><title>Chat Model Warmer</title></head>
         <body>
-            <div class="container">
-                <h1>⚡ FastAPI Pinger</h1>
-                <p><strong>Target Servers:</strong> {len(target_servers)}</p>
-                <p><strong>Pinger Network:</strong> {len(pinger_spaces)}</p>
-                <p><strong>Last Run:</strong> {last_ping_run.strftime('%Y-%m-%d %H:%M:%S') if last_ping_run else 'Not yet'}</p>
-                <p><strong>Status:</strong> {success_count}/{len(target_servers)} servers OK • {health_success}/{len(pinger_spaces)} pingers OK</p>
-                
-                <h3>Endpoints:</h3>
-                <ul>
-                    <li><a href="error</a></li>
-                </ul>
-            </div>
+            <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>
         </body>
     </html>
     """
@@ -181,49 +252,22 @@ async def home():
 
 @app.get("/health")
 async def health():
-    """Health endpoint for other pingers"""
     return JSONResponse({
         "status": "healthy",
-        "service": "fastapi-pinger",
-        "timestamp": datetime.now().isoformat(),
-        "server_count": len(target_servers),
-        "network_count": len(pinger_spaces),
-        "last_ping": last_ping_run.isoformat() if last_ping_run else None
+        "service": "chat-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
     })
 
-@app.get("/results")
-async def get_results():
-    """Get current ping results"""
+@app.get("/status")
+async def status():
     return JSONResponse({
-        "last_run": last_ping_run.isoformat() if last_ping_run else None,
-        "target_servers": ping_results,
-        "pinger_network": health_results,
+        "regular_servers": ping_results,
+        "chat_models": chat_warmup_results,
         "timestamp": datetime.now().isoformat()
     })
 
-@app.get("/ping-now")
-async def ping_now():
-    """Manually trigger a ping cycle"""
-    results = await ping_all_servers()
-    if pinger_spaces:
-        await ping_health_endpoints()
-    
-    success_count = sum(1 for result in results if result['status'] == 'success')
-    health_success = sum(1 for result in health_results.values() if result.get('status') == 'success')
-    
-    return JSONResponse({
-        "message": "Manual ping completed",
-        "servers_ok": f"{success_count}/{len(target_servers)}",
-        "pingers_ok": f"{health_success}/{len(pinger_spaces)}",
-        "timestamp": datetime.now().isoformat()
-    })
-
-@app.get("/docs")
-async def get_docs():
-    """Redirect to interactive docs"""
-    from fastapi.responses import RedirectResponse
-    return RedirectResponse(url="/docs")
-
 if __name__ == "__main__":
     import uvicorn
     uvicorn.run(app, host="0.0.0.0", port=7860)