skip examples caching

app.py

@@ -21,6 +21,7 @@ import os
 HF_TOKEN = os.getenv("HF_TOKEN")
 if not HF_TOKEN:
     logger.warning("HF_TOKEN not found in environment variables. Model access may be restricted.")
+    logger.warning("Please set HF_TOKEN in your environment variables or Spaces secrets.")
 
 class LOperatorDemo:
     def __init__(self):
@@ -29,15 +30,18 @@ class LOperatorDemo:
         self.is_loaded = False
         
     def load_model(self):
-        """Load the L-Operator model and processor"""
+        """Load the L-Operator model and processor with timeout handling"""
         try:
+            import time
+            start_time = time.time()
             logger.info(f"Loading model {MODEL_ID} on device {DEVICE}")
-            
+
             # Check if token is available
             if not HF_TOKEN:
                 return "❌ HF_TOKEN not found. Please set HF_TOKEN in Spaces secrets."
-            
-            # Load model following the working example pattern
+
+            # Load model with progress logging
+            logger.info("Downloading and loading model weights...")
             self.model = AutoModelForImageTextToText.from_pretrained(
                 MODEL_ID,
                 device_map="auto",
@@ -46,17 +50,20 @@ class LOperatorDemo:
             )
 
             # Load processor
+            logger.info("Loading processor...")
             self.processor = AutoProcessor.from_pretrained(
                 MODEL_ID,
                 trust_remote_code=True
-            )            
+            )
+
             if DEVICE == "cpu":
                 self.model = self.model.to(DEVICE)
-            
+
             self.is_loaded = True
-            logger.info("Model loaded successfully with token authentication")
-            return "✅ Model loaded successfully with token authentication!"
-            
+            load_time = time.time() - start_time
+            logger.info(".1f")
+            return ".1f"
+
         except Exception as e:
             logger.error(f"Error loading model: {str(e)}")
             return f"❌ Error loading model: {str(e)} - This may be a custom model requiring special handling"
@@ -163,74 +170,72 @@ class LOperatorDemo:
 # Initialize demo
 demo_instance = LOperatorDemo()
 
-# Auto-load the model on startup
-def auto_load_model():
-    """Auto-load the model when the application starts"""
+def load_model_with_timeout(timeout_seconds=600):  # 10 minutes timeout
+    """Load model with timeout protection"""
+    import signal
+    import time
+
+    def timeout_handler(signum, frame):
+        raise TimeoutError("Model loading timed out")
+
+    # Set up the signal handler for timeout
+    old_handler = signal.signal(signal.SIGALRM, timeout_handler)
+    signal.alarm(timeout_seconds)
+
     try:
-        logger.info("Auto-loading L-Operator model on startup...")
+        logger.info("Loading L-Operator model with timeout protection...")
         result = demo_instance.load_model()
-        logger.info(f"Auto-load result: {result}")
+        logger.info(f"Model loading result: {result}")
         return result
+    except TimeoutError:
+        logger.error("Model loading timed out - this may be due to network issues or large model size")
+        return "❌ Model loading timed out. Please try again or check your internet connection."
     except Exception as e:
-        logger.error(f"Error auto-loading model: {str(e)}")
-        return f"❌ Error auto-loading model: {str(e)}"
-
-# Load model automatically (this happens during import)
-print("🚀 Auto-loading L-Operator model on startup...")
-auto_load_model()
-print("✅ Model loading completed!")
+        logger.error(f"Error loading model: {str(e)}")
+        return f"❌ Error loading model: {str(e)}"
+    finally:
+        # Restore the original signal handler
+        signal.alarm(0)
+        signal.signal(signal.SIGALRM, old_handler)
 
-# Load example episodes
+# Load example episodes (lazy loading to avoid startup timeout)
 def load_example_episodes():
-    """Load example episodes from the extracted data with error handling"""
+    """Load example episodes from the extracted data - simplified for fast startup"""
     examples = []
 
     try:
-        # Load episode 13
-        with open("extracted_episodes_duckdb/episode_13/metadata.json", "r") as f:
-            episode_13 = json.load(f)
-
-        # Load episode 53
-        with open("extracted_episodes_duckdb/episode_53/metadata.json", "r") as f:
-            episode_53 = json.load(f)
+        # Load episode metadata quickly without PIL validation
+        episodes_data = []
+        episode_dirs = ["episode_13", "episode_53", "episode_73"]
 
-        # Load episode 73
-        with open("extracted_episodes_duckdb/episode_73/metadata.json", "r") as f:
-            episode_73 = json.load(f)
-        
-        # Create examples with simple identifiers
-        examples = [
-            (
-                "extracted_episodes_duckdb/episode_13/screenshots/screenshot_1.png",
-                f"Episode 13: {episode_13.get('goal', 'Navigate app interface')[:50]}..."
-            ),
-            (
-                "extracted_episodes_duckdb/episode_53/screenshots/screenshot_1.png",
-                f"Episode 53: {episode_53.get('goal', 'App interaction example')[:50]}..."
-            ),
-            (
-                "extracted_episodes_duckdb/episode_73/screenshots/screenshot_1.png",
-                f"Episode 73: {episode_73.get('goal', 'Device control task')[:50]}..."
-            )
-        ]
-
-        # Validate each example by checking if image file exists and is readable
-        for image_path, description in examples:
+        for episode_dir in episode_dirs:
             try:
-                # Try to open the image to validate it
-                from PIL import Image
-                with Image.open(image_path) as img:
-                    # If we get here, the image is valid
-                    examples.append([image_path, description])
-            except Exception as img_error:
-                logger.warning(f"Skipping invalid image {image_path}: {str(img_error)}")
+                metadata_path = f"extracted_episodes_duckdb/{episode_dir}/metadata.json"
+                with open(metadata_path, "r") as f:
+                    metadata = json.load(f)
+                    episodes_data.append(metadata)
+            except Exception as e:
+                logger.warning(f"Could not load metadata for {episode_dir}: {str(e)}")
                 continue
 
+        # Create examples with simple path checks (no PIL validation)
+        for i, metadata in enumerate(episodes_data):
+            episode_num = ["13", "53", "73"][i]
+            image_path = f"extracted_episodes_duckdb/episode_{episode_num}/screenshots/screenshot_1.png"
+
+            # Simple file existence check instead of PIL validation
+            if os.path.exists(image_path):
+                goal_text = metadata.get('goal', f'Episode {episode_num} example')
+                examples.append([
+                    image_path,
+                    f"Episode {episode_num}: {goal_text[:50]}..."
+                ])
+
     except Exception as e:
         logger.error(f"Error loading examples: {str(e)}")
         examples = []
 
-    logger.info(f"Loaded {len(examples)} valid examples")
+    logger.info(f"Loaded {len(examples)} examples (without validation for faster startup)")
     return examples
 
 # Create Gradio interface
@@ -322,7 +327,8 @@ def create_demo():
                     title="L-Operator Chat",
                     description="Chat with L-Operator using screenshots and text instructions",
                     examples=load_example_episodes(),
-                    type="messages"
+                    type="messages",
+                    cache_examples=False 
                 )
                 
                 gr.Markdown("### 🎯 Action Output")
@@ -349,20 +355,26 @@ def create_demo():
             except:
                 return {"raw_response": response}
         
-        # Update model status on page load
+        # Update model status on page load (with timeout-protected model loading)
         def update_model_status():
+            if not demo_instance.is_loaded:
+                logger.info("Loading model on Gradio startup with timeout protection...")
+                result = load_model_with_timeout(timeout_seconds=900)  # 15 minutes for Spaces
+                logger.info(f"Model loading result: {result}")
+                return result
+
             if demo_instance.is_loaded:
                 return "✅ L-Operator model loaded and ready!"
             else:
                 return "❌ Model failed to load. Please check logs."
-        
+
         generate_btn.click(
             fn=on_generate_action,
             inputs=[image_input, goal_input, step_input],
             outputs=action_output
         )
-        
-        # Update model status on page load
+
+        # Load model and update status on page load
         demo.load(
             fn=update_model_status,
             outputs=model_status
@@ -404,14 +416,23 @@ def create_demo():
     
     return demo
 
-# Create and launch the demo
+# Create and launch the demo with optimized settings
 if __name__ == "__main__":
-    demo = create_demo()
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=False,
-        debug=True,
-        show_error=True,
-        ssr_mode=False
-    )
+    try:
+        logger.info("Creating Gradio demo interface...")
+        demo = create_demo()
+
+        logger.info("Launching Gradio server...")
+        demo.launch(
+            server_name="0.0.0.0",
+            server_port=7860,
+            share=False,
+            debug=False,  # Disable debug to reduce startup time
+            show_error=True,
+            ssr_mode=False,
+            max_threads=2,  # Limit threads to prevent resource exhaustion
+            quiet=True  # Reduce startup logging noise
+        )
+    except Exception as e:
+        logger.error(f"Failed to launch Gradio app: {str(e)}")
+        raise