Update app.py

app.py

@@ -23,7 +23,7 @@ regular_servers = [
     "https://rajhuggingface4253-compressor3pro.hf.space"
 ]
 
-# Models to warm with SIMPLE payloads - let's test what works
+# Models to warm - SIMPLE and CLEAN
 models_to_warm = [
     {
         "name": "Qwen 1",
@@ -32,7 +32,9 @@ models_to_warm = [
         "type": "streaming_chat",
         "timeout": 30.0,
         "payload": {
-            "prompt": "Hello, are you ready?"
+            "prompt": "Hello, respond with OK if ready",
+            "max_new_tokens": 10,
+            "temperature": 0.1
         }
     },
     {
@@ -42,7 +44,9 @@ models_to_warm = [
         "type": "streaming_chat",
         "timeout": 30.0,
         "payload": {
-            "prompt": "Say 'ready' if you're working."
+            "prompt": "Hello, respond with OK if ready",
+            "max_new_tokens": 10,
+            "temperature": 0.1
         }
     },
     {
@@ -52,7 +56,9 @@ models_to_warm = [
         "type": "streaming_chat",
         "timeout": 30.0,
         "payload": {
-            "prompt": "Ping! Respond with 'pong'."
+            "prompt": "Hello, respond with OK if ready",
+            "max_new_tokens": 10,
+            "temperature": 0.1
         }
     },
     {
@@ -93,7 +99,7 @@ async def ping_server(url: str) -> Dict:
         }
 
 async def warmup_streaming_model(model_config: Dict) -> Dict:
-    """Warm up streaming models by calling their chat endpoints"""
+    """Warm up streaming models - SIMPLE and EFFECTIVE"""
     try:
         start_time = time.time()
         async with httpx.AsyncClient(timeout=model_config.get('timeout', 30.0)) as client:
@@ -101,21 +107,13 @@ async def warmup_streaming_model(model_config: Dict) -> Dict:
             payload = model_config['payload']
             api_url = f"{model_config['url']}{model_config['endpoint']}"
             
-            # Make the streaming request
+            # Simple POST request to chat endpoint
             response = await client.post(api_url, json=payload)
             
             if response.status_code != 200:
-                # Try to get error details for debugging
-                error_detail = ""
-                try:
-                    error_response = await response.text()
-                    error_detail = f" - {error_response[:100]}"
-                except:
-                    pass
-                    
                 return {
                     'status': 'error',
-                    'error': f"HTTP {response.status_code}{error_detail}",
+                    'error': f"HTTP {response.status_code}",
                     'status_code': response.status_code,
                     'response_time_ms': round((time.time() - start_time) * 1000, 1),
                     'got_response': False,
@@ -130,13 +128,13 @@ async def warmup_streaming_model(model_config: Dict) -> Dict:
             
             response_time = round((time.time() - start_time) * 1000, 1)
             
-            # Check if we got a valid response
+            # Success if we got any response
             if collected_response:
                 return {
                     'status': 'success',
                     'response_time_ms': response_time,
                     'status_code': response.status_code,
-                    'model_response': collected_response[:200] + "..." if len(collected_response) > 200 else collected_response,
+                    'model_response': collected_response[:100],
                     'response_length': len(collected_response),
                     'got_response': True,
                     'timestamp': datetime.now().isoformat()
@@ -144,7 +142,7 @@ async def warmup_streaming_model(model_config: Dict) -> Dict:
             else:
                 return {
                     'status': 'error',
-                    'error': 'Empty streaming response',
+                    'error': 'No response received',
                     'response_time_ms': response_time,
                     'status_code': response.status_code,
                     'got_response': False,
@@ -179,39 +177,18 @@ async def warmup_model_health(model_config: Dict) -> Dict:
             response_time = round((time.time() - start_time) * 1000, 1)
             
             if response.status_code == 200:
-                try:
-                    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:
-                    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()
-                    }
+                return {
+                    'status': 'success',
+                    'response_time_ms': response_time,
+                    'status_code': response.status_code,
+                    '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()
                 }
@@ -221,14 +198,12 @@ async def warmup_model_health(model_config: Dict) -> Dict:
             '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()
         }
 
 async def warmup_single_model(model_config: Dict) -> Dict:
-    """Route to appropriate warming method based on model type"""
+    """Route to appropriate warming method"""
     if model_config.get('type') == 'streaming_chat':
         return await warmup_streaming_model(model_config)
     else:
@@ -255,7 +230,7 @@ async def ping_all_servers():
     return results
 
 async def warmup_all_models():
-    """Warm up all models using appropriate endpoints"""
+    """Warm up all models"""
     global model_warmup_results, last_model_warmup
     
     if not models_to_warm:
@@ -270,18 +245,15 @@ async def warmup_all_models():
             'health_check': results[i]
         }
         
-        # Log results
         result = results[i]
         model_name = model['name']
         
         if result['status'] == 'success':
+            response_time = result['response_time_ms']
             if result.get('got_response'):
-                response_info = f"{result['response_time_ms']}ms"
-                if result.get('response_length'):
-                    response_info += f" ({result['response_length']} chars)"
-                print(f"✅ {model_name}: {response_info}")
+                print(f"✅ {model_name}: {response_time}ms")
             else:
-                print(f"✅ {model_name}: {result['response_time_ms']}ms")
+                print(f"✅ {model_name}: {response_time}ms")
         else:
             error_msg = result.get('error', 'Unknown error')
             print(f"❌ {model_name}: {error_msg}")
@@ -328,7 +300,7 @@ async def ping_single_health(client: httpx.AsyncClient, space_url: str, health_u
         print(f"🔗 Health ping failed for {space_url}: {e}")
 
 async def continuous_pinging():
-    """Main pinging loop with model warming"""
+    """Main pinging loop"""
     print("🚀 Smart Model Warmer Started!")
     print(f"🌐 Regular servers: {len(regular_servers)}")
     print(f"🤖 Models to warm: {len(models_to_warm)}")