adds examples and model loading

app.py

@@ -61,8 +61,8 @@ class LOperatorDemo:
 
             self.is_loaded = True
             load_time = time.time() - start_time
-            logger.info(".1f")
-            return ".1f"
+            logger.info(f"Model loaded successfully in {load_time:.1f} seconds")
+            return f"✅ Model loaded successfully in {load_time:.1f} seconds"
 
         except Exception as e:
             logger.error(f"Error loading model: {str(e)}")
@@ -170,72 +170,60 @@ class LOperatorDemo:
 # Initialize demo
 demo_instance = LOperatorDemo()
 
-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)
-
+def load_model():
+    """Load model normally"""
     try:
-        logger.info("Loading L-Operator model with timeout protection...")
+        logger.info("Loading L-Operator model...")
         result = demo_instance.load_model()
         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 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 (lazy loading to avoid startup timeout)
 def load_example_episodes():
-    """Load example episodes from the extracted data - simplified for fast startup"""
+    """Load example episodes from the extracted data - properly load images for Gradio"""
     examples = []
 
     try:
-        # Load episode metadata quickly without PIL validation
-        episodes_data = []
+        # Load episode metadata and images
         episode_dirs = ["episode_13", "episode_53", "episode_73"]
 
         for episode_dir in episode_dirs:
             try:
                 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)
+                image_path = f"extracted_episodes_duckdb/{episode_dir}/screenshots/screenshot_1.png"
+                
+                # Check if both files exist
+                if os.path.exists(metadata_path) and os.path.exists(image_path):
+                    with open(metadata_path, "r") as f:
+                        metadata = json.load(f)
+                    
+                    # Load the image using PIL
+                    image = Image.open(image_path)
+                    
+                    # Ensure image is in RGB mode
+                    if image.mode != "RGB":
+                        image = image.convert("RGB")
+                    
+                    episode_num = episode_dir.split('_')[1]
+                    goal_text = metadata.get('goal', f'Episode {episode_num} example')
+                    
+                    examples.append([
+                        image,  # Use PIL Image object instead of file path
+                        f"Episode {episode_num}: {goal_text[:50]}..."
+                    ])
+                    
             except Exception as e:
-                logger.warning(f"Could not load metadata for {episode_dir}: {str(e)}")
+                logger.warning(f"Could not load example 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)} examples (without validation for faster startup)")
+    logger.info(f"Loaded {len(examples)} examples with proper image loading")
     return examples
 
 # Create Gradio interface
@@ -321,12 +309,19 @@ def create_demo():
                 
             with gr.Column(scale=2):
                 gr.Markdown("### 💬 Chat Interface")
+                # Load examples with error handling
+                try:
+                    examples = load_example_episodes()
+                except Exception as e:
+                    logger.warning(f"Failed to load examples: {str(e)}")
+                    examples = []
+                
                 chat_interface = gr.ChatInterface(
                     fn=demo_instance.chat_with_model,
                     additional_inputs=[image_input],
                     title="L-Operator Chat",
                     description="Chat with L-Operator using screenshots and text instructions",
-                    examples=load_example_episodes(),
+                    examples=examples,
                     type="messages",
                     cache_examples=False 
                 )
@@ -355,11 +350,11 @@ def create_demo():
             except:
                 return {"raw_response": response}
         
-        # Update model status on page load (with timeout-protected model loading)
+        # Update model status on page load
         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("Loading model on Gradio startup...")
+                result = load_model()
                 logger.info(f"Model loading result: {result}")
                 return result
 
@@ -380,15 +375,8 @@ def create_demo():
             outputs=model_status
         )
         
-        # Update chat interface when image changes
-        def update_chat_image(image):
-            return image
-        
-        image_input.change(
-            fn=update_chat_image,
-            inputs=[image_input],
-            outputs=[chat_interface.chatbot]
-        )
+        # Note: The chat interface will automatically handle image updates
+        # No need for manual image change handling
         
         gr.Markdown("""
         ---