Update app.py

app.py

@@ -34,226 +34,99 @@ logging.basicConfig(level=logging.INFO,
 logger = logging.getLogger("set_detector")
 
 # =============================================================================
-# MODEL PATHS & LOADING
+# MODEL PATHS
 # =============================================================================
 # For loading models from Hugging Face Hub
 HF_MODEL_REPO_PREFIX = "Omamitai"
-
-# Define model repos and paths
 CARD_DETECTION_REPO = f"{HF_MODEL_REPO_PREFIX}/card-detection"
 SHAPE_DETECTION_REPO = f"{HF_MODEL_REPO_PREFIX}/shape-detection"
 SHAPE_CLASSIFICATION_REPO = f"{HF_MODEL_REPO_PREFIX}/shape-classification"
 FILL_CLASSIFICATION_REPO = f"{HF_MODEL_REPO_PREFIX}/fill-classification"
 
-# Model filenames
 CARD_MODEL_FILENAME = "best.pt"
 SHAPE_MODEL_FILENAME = "best.pt"
 SHAPE_CLASS_MODEL_FILENAME = "shape_model.keras"
 FILL_CLASS_MODEL_FILENAME = "fill_model.keras"
 
-# For local testing: fallback to local models if HF downloads fail
-# Use the local directory structure as fallback
-if os.path.exists("/home/user"):  # Check if we're on HF Spaces
-    local_base_dir = Path("/home/user/app/models")
-else:
-    local_base_dir = Path(os.path.dirname(os.path.abspath(__file__))) / "models"
-
-local_char_path = local_base_dir / "Characteristics" / "11022025"
-local_shape_path = local_base_dir / "Shape" / "15052024"
-local_card_path = local_base_dir / "Card" / "16042024"
-
 # Global variables for model caching
 _MODEL_SHAPE = None
 _MODEL_FILL = None
 _DETECTOR_CARD = None
 _DETECTOR_SHAPE = None
-_MODELS_LOADED = False
-_MODEL_LOADING_ERROR = None
 
-def load_classification_models() -> Tuple[tf.keras.Model, tf.keras.Model]:
+def load_models():
     """
-    Loads the Keras models for 'shape' and 'fill' classification from HuggingFace Hub.
-    Returns (shape_model, fill_model).
+    Load all models needed for SET detection.
+    Returns tuple of (card_detector, shape_detector, shape_model, fill_model)
     """
-    global _MODEL_SHAPE, _MODEL_FILL, _MODEL_LOADING_ERROR
+    global _MODEL_SHAPE, _MODEL_FILL, _DETECTOR_CARD, _DETECTOR_SHAPE
     
-    # If models are already loaded, return them
-    if _MODEL_SHAPE is not None and _MODEL_FILL is not None:
-        return _MODEL_SHAPE, _MODEL_FILL
+    # Return cached models if already loaded
+    if all([_MODEL_SHAPE, _MODEL_FILL, _DETECTOR_CARD, _DETECTOR_SHAPE]):
+        return _DETECTOR_CARD, _DETECTOR_SHAPE, _MODEL_SHAPE, _MODEL_FILL
     
     try:
         from huggingface_hub import hf_hub_download
         
-        # Try to download from HuggingFace Hub
-        logger.info(f"Downloading shape classification model from {SHAPE_CLASSIFICATION_REPO}...")
+        # Download and load YOLO models
+        logger.info("Downloading detection models...")
+        card_model_path = hf_hub_download(
+            repo_id=CARD_DETECTION_REPO, 
+            filename=CARD_MODEL_FILENAME,
+            cache_dir="./hf_cache"
+        )
+        
         shape_model_path = hf_hub_download(
+            repo_id=SHAPE_DETECTION_REPO, 
+            filename=SHAPE_MODEL_FILENAME,
+            cache_dir="./hf_cache"
+        )
+        
+        # Download and load classification models
+        logger.info("Downloading classification models...")
+        shape_class_path = hf_hub_download(
             repo_id=SHAPE_CLASSIFICATION_REPO, 
             filename=SHAPE_CLASS_MODEL_FILENAME,
             cache_dir="./hf_cache"
         )
         
-        logger.info(f"Downloading fill classification model from {FILL_CLASSIFICATION_REPO}...")
-        fill_model_path = hf_hub_download(
+        fill_class_path = hf_hub_download(
             repo_id=FILL_CLASSIFICATION_REPO, 
             filename=FILL_CLASS_MODEL_FILENAME,
             cache_dir="./hf_cache"
         )
         
-        # Load the models
-        logger.info("Loading classification models...")
-        model_shape = load_model(str(shape_model_path))
-        model_fill = load_model(str(fill_model_path))
-        
-        logger.info("Classification models loaded successfully")
-        _MODEL_SHAPE, _MODEL_FILL = model_shape, model_fill
-        return model_shape, model_fill
-    
-    except Exception as e:
-        error_msg = f"Error downloading classification models from HF Hub: {str(e)}"
-        logger.error(error_msg)
+        # Load all models
+        logger.info("Loading models...")
+        card_detector = YOLO(str(card_model_path))
+        card_detector.conf = 0.5
         
-        # Try fallback to local files
-        try:
-            logger.info("Trying fallback to local model files...")
-            shape_model_path = local_char_path / SHAPE_CLASS_MODEL_FILENAME
-            fill_model_path = local_char_path / FILL_CLASS_MODEL_FILENAME
-            
-            if not shape_model_path.exists() or not fill_model_path.exists():
-                raise FileNotFoundError("Local model files not found")
-                
-            # Load the models
-            model_shape = load_model(str(shape_model_path))
-            model_fill = load_model(str(fill_model_path))
-            
-            logger.info("Classification models loaded successfully from local files")
-            _MODEL_SHAPE, _MODEL_FILL = model_shape, model_fill
-            return model_shape, model_fill
-            
-        except Exception as fallback_error:
-            error_msg = f"{error_msg}\nFallback to local files also failed: {str(fallback_error)}"
-            logger.error(error_msg)
-            _MODEL_LOADING_ERROR = error_msg
-            return None, None
-
-def load_detection_models() -> Tuple[YOLO, YOLO]:
-    """
-    Loads the YOLO detection models for cards and shapes from HuggingFace Hub.
-    Returns (card_detector, shape_detector).
-    """
-    global _DETECTOR_CARD, _DETECTOR_SHAPE, _MODEL_LOADING_ERROR
-    
-    # If models are already loaded, return them
-    if _DETECTOR_CARD is not None and _DETECTOR_SHAPE is not None:
-        return _DETECTOR_CARD, _DETECTOR_SHAPE
-    
-    try:
-        from huggingface_hub import hf_hub_download
+        shape_detector = YOLO(str(shape_model_path))
+        shape_detector.conf = 0.5
         
-        # Try to download from HuggingFace Hub
-        logger.info(f"Downloading card detection model from {CARD_DETECTION_REPO}...")
-        card_model_path = hf_hub_download(
-            repo_id=CARD_DETECTION_REPO, 
-            filename=CARD_MODEL_FILENAME,
-            cache_dir="./hf_cache"
-        )
-        
-        logger.info(f"Downloading shape detection model from {SHAPE_DETECTION_REPO}...")
-        shape_model_path = hf_hub_download(
-            repo_id=SHAPE_DETECTION_REPO, 
-            filename=SHAPE_MODEL_FILENAME,
-            cache_dir="./hf_cache"
-        )
-        
-        # Load the models
-        logger.info("Loading detection models...")
-        detector_shape = YOLO(str(shape_model_path))
-        detector_shape.conf = 0.5
-        detector_card = YOLO(str(card_model_path))
-        detector_card.conf = 0.5
+        shape_classifier = load_model(str(shape_class_path))
+        fill_classifier = load_model(str(fill_class_path))
         
         # Use GPU if available
         if torch.cuda.is_available():
             logger.info("CUDA is available. Using GPU for inference.")
-            detector_card.to("cuda")
-            detector_shape.to("cuda")
-        else:
-            logger.info("CUDA is not available. Using CPU for inference.")
-            
-        logger.info("Detection models loaded successfully")
-        _DETECTOR_CARD, _DETECTOR_SHAPE = detector_card, detector_shape
-        return detector_card, detector_shape
+            card_detector.to("cuda")
+            shape_detector.to("cuda")
         
-    except Exception as e:
-        error_msg = f"Error downloading detection models from HF Hub: {str(e)}"
-        logger.error(error_msg)
+        # Cache the models
+        _DETECTOR_CARD = card_detector
+        _DETECTOR_SHAPE = shape_detector
+        _MODEL_SHAPE = shape_classifier
+        _MODEL_FILL = fill_classifier
         
-        # Try fallback to local files
-        try:
-            logger.info("Trying fallback to local model files...")
-            shape_model_path = local_shape_path / SHAPE_MODEL_FILENAME
-            card_model_path = local_card_path / CARD_MODEL_FILENAME
-            
-            if not shape_model_path.exists() or not card_model_path.exists():
-                raise FileNotFoundError("Local model files not found")
-                
-            # Load the models
-            detector_shape = YOLO(str(shape_model_path))
-            detector_shape.conf = 0.5
-            detector_card = YOLO(str(card_model_path))
-            detector_card.conf = 0.5
-            
-            # Use GPU if available
-            if torch.cuda.is_available():
-                logger.info("CUDA is available. Using GPU for inference.")
-                detector_card.to("cuda")
-                detector_shape.to("cuda")
-                
-            logger.info("Detection models loaded successfully from local files")
-            _DETECTOR_CARD, _DETECTOR_SHAPE = detector_card, detector_shape
-            return detector_card, detector_shape
-            
-        except Exception as fallback_error:
-            error_msg = f"{error_msg}\nFallback to local files also failed: {str(fallback_error)}"
-            logger.error(error_msg)
-            _MODEL_LOADING_ERROR = error_msg
-            return None, None
-
-def load_all_models() -> bool:
-    """
-    Loads all required models and returns True if successful.
-    """
-    global _MODELS_LOADED, _MODEL_LOADING_ERROR
-    
-    if _MODELS_LOADED:
-        return True
-    
-    try:
-        model_shape, model_fill = load_classification_models()
-        detector_card, detector_shape = load_detection_models()
+        logger.info("All models loaded successfully!")
+        return card_detector, shape_detector, shape_classifier, fill_classifier
         
-        models_loaded = all([model_shape, model_fill, detector_card, detector_shape])
-        _MODELS_LOADED = models_loaded
-        
-        if not models_loaded and _MODEL_LOADING_ERROR is None:
-            _MODEL_LOADING_ERROR = "Unknown error loading models"
-            
-        return models_loaded
     except Exception as e:
         error_msg = f"Error loading models: {str(e)}"
         logger.error(error_msg)
-        _MODEL_LOADING_ERROR = error_msg
-        return False
-
-def get_model_status() -> str:
-    """
-    Returns a status message about the models.
-    """
-    if _MODELS_LOADED:
-        return "All models loaded successfully!"
-    elif _MODEL_LOADING_ERROR:
-        return f"Error: {_MODEL_LOADING_ERROR}"
-    else:
-        return "Models not loaded yet. Click 'Load Models' to preload them."
+        logger.error(traceback.format_exc())
+        raise ValueError(error_msg)
 
 # =============================================================================
 # UTILITY & DETECTION FUNCTIONS
@@ -487,57 +360,6 @@ def draw_detected_sets(board_img: np.ndarray, sets_detected: List[dict]) -> np.n
                 )
     return board_img
 
-def identify_sets_from_image(
-    board_img: np.ndarray
-) -> Tuple[List[dict], np.ndarray, str]:
-    """
-    End-to-end pipeline to classify cards on the board and detect valid sets.
-    Returns a tuple of (list of sets, annotated image, status message).
-    """
-    # Load models
-    if not load_all_models():
-        error_msg = _MODEL_LOADING_ERROR or "Error: Could not load models."
-        return [], board_img, error_msg
-    
-    card_detector, shape_detector = _DETECTOR_CARD, _DETECTOR_SHAPE
-    model_shape, model_fill = _MODEL_SHAPE, _MODEL_FILL
-    
-    # Convert image to BGR if needed (OpenCV format)
-    if len(board_img.shape) == 3 and board_img.shape[2] == 4:  # RGBA
-        board_img = cv2.cvtColor(board_img, cv2.COLOR_RGBA2BGR)
-    elif len(board_img.shape) == 3 and board_img.shape[2] == 3:
-        # We assume the image is already in BGR format (OpenCV standard)
-        # If it's in RGB format (common from web uploads), we'll convert it
-        board_img = cv2.cvtColor(board_img, cv2.COLOR_RGB2BGR)
-    else:
-        return [], board_img, "Error: Unsupported image format. Please upload a color image."
-    
-    # 1. Check and fix orientation if needed
-    processed, was_rotated = verify_and_rotate_image(board_img, card_detector)
-
-    # 2. Verify that cards are present
-    cards = detect_cards(processed, card_detector)
-    if not cards:
-        return [], cv2.cvtColor(board_img, cv2.COLOR_BGR2RGB), "No cards detected in the image. Please check that it's a SET game board."
-
-    # 3. Classify each card's features, then find sets
-    df_cards = classify_cards_on_board(processed, card_detector, shape_detector, model_fill, model_shape)
-    found_sets = locate_all_sets(df_cards)
-
-    if not found_sets:
-        return [], cv2.cvtColor(processed, cv2.COLOR_BGR2RGB), "Cards detected, but no valid SETs found. You may need to add more cards to the table!"
-
-    # 4. Draw sets on a copy of the image
-    annotated = draw_detected_sets(processed.copy(), found_sets)
-
-    # 5. Restore orientation if we rotated earlier
-    final_output = restore_orientation(annotated, was_rotated)
-    
-    # Convert back to RGB for display
-    final_output_rgb = cv2.cvtColor(final_output, cv2.COLOR_BGR2RGB)
-    
-    return found_sets, final_output_rgb, f"Found {len(found_sets)} SET(s) in the image."
-
 def optimize_image_size(image_array: np.ndarray, max_dim=1200) -> np.ndarray:
     """
     Resizes an image if its largest dimension exceeds max_dim, to reduce processing time.
@@ -557,46 +379,57 @@ def optimize_image_size(image_array: np.ndarray, max_dim=1200) -> np.ndarray:
         return cv2.resize(image_array, (new_width, new_height), interpolation=cv2.INTER_AREA)
     return image_array
 
-# =============================================================================
-# MAIN PROCESSING FUNCTIONS FOR GRADIO
-# =============================================================================
-def preload_models():
-    """
-    Function to preload models and return status.
-    """
-    try:
-        if load_all_models():
-            return "Models loaded successfully! Ready to detect SETs."
-        else:
-            return f"Error loading models: {_MODEL_LOADING_ERROR or 'Unknown error'}"
-    except Exception as e:
-        return f"Error loading models: {str(e)}"
-
 @spaces.GPU
-def process_set_image(input_image):
+def process_image(input_image):
     """
-    Main processing function for the Gradio interface.
-    Takes an input image, processes it to find SETs, and returns the output image and status.
-    
-    Uses @spaces.GPU for Hugging Face Spaces zero-GPU optimization.
+    Main processing function for SET detection.
+    Takes an input image, processes it, and returns the annotated image and status.
     """
     if input_image is None:
         return None, "Please upload an image."
     
     try:
         start_time = time.time()
-        logger.info("Processing image...")
         
-        # Check if image needs to be optimized (resized)
-        optimized_image = optimize_image_size(input_image)
+        # Load models
+        card_detector, shape_detector, shape_model, fill_model = load_models()
         
-        # Identify sets
-        found_sets, annotated_image, status_message = identify_sets_from_image(optimized_image)
+        # Optimize image size
+        optimized_img = optimize_image_size(input_image)
         
-        process_time = time.time() - start_time
-        logger.info(f"Image processed in {process_time:.2f} seconds.")
+        # Convert to BGR if needed (OpenCV format)
+        if len(optimized_img.shape) == 3 and optimized_img.shape[2] == 4:  # RGBA
+            optimized_img = cv2.cvtColor(optimized_img, cv2.COLOR_RGBA2BGR)
+        elif len(optimized_img.shape) == 3 and optimized_img.shape[2] == 3:
+            # RGB to BGR
+            optimized_img = cv2.cvtColor(optimized_img, cv2.COLOR_RGB2BGR)
         
-        return annotated_image, status_message
+        # Check and fix orientation
+        processed_img, was_rotated = verify_and_rotate_image(optimized_img, card_detector)
+        
+        # Detect cards
+        cards = detect_cards(processed_img, card_detector)
+        if not cards:
+            return cv2.cvtColor(optimized_img, cv2.COLOR_BGR2RGB), "No cards detected. Please check that it's a SET game board."
+        
+        # Classify cards and find sets
+        df_cards = classify_cards_on_board(processed_img, card_detector, shape_detector, fill_model, shape_model)
+        found_sets = locate_all_sets(df_cards)
+        
+        if not found_sets:
+            return cv2.cvtColor(processed_img, cv2.COLOR_BGR2RGB), "Cards detected, but no valid SETs found!"
+        
+        # Draw sets on the image
+        annotated = draw_detected_sets(processed_img.copy(), found_sets)
+        
+        # Restore original orientation if needed
+        final_output = restore_orientation(annotated, was_rotated)
+        
+        # Convert back to RGB for display
+        final_output_rgb = cv2.cvtColor(final_output, cv2.COLOR_BGR2RGB)
+        
+        process_time = time.time() - start_time
+        return final_output_rgb, f"Found {len(found_sets)} SET(s) in {process_time:.2f} seconds."
         
     except Exception as e:
         error_message = f"Error processing image: {str(e)}"
@@ -604,205 +437,69 @@ def process_set_image(input_image):
         logger.error(traceback.format_exc())
         return input_image, error_message
 
+# Create examples directory
+examples_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "examples")
+os.makedirs(examples_dir, exist_ok=True)
+
 # =============================================================================
 # GRADIO INTERFACE
 # =============================================================================
-def create_gradio_interface():
-    """
-    Creates and returns the Gradio interface for the SET Game Detector.
-    """
-    # CSS for styling the Gradio interface
-    css = """
-    @import url('https://fonts.googleapis.com/css2?family=Poppins:wght@400;500;600;700&display=swap');
-    
-    .gradio-container {
-        font-family: 'Poppins', sans-serif;
-    }
-    .app-header {
-        text-align: center;
-        margin-bottom: 20px;
-        background: linear-gradient(90deg, rgba(124, 58, 237, 0.1) 0%, rgba(236, 72, 153, 0.1) 100%);
-        padding: 1rem;
-        border-radius: 12px;
-    }
-    .app-header h1 {
-        font-size: 2.5rem;
-        background: linear-gradient(90deg, #8B5CF6 0%, #7C3AED 50%, #EC4899 100%);
-        -webkit-background-clip: text;
-        background-clip: text;
-        -webkit-text-fill-color: transparent;
-        margin-bottom: 5px;
-    }
-    .app-header p {
-        font-size: 1.1rem;
-        opacity: 0.8;
-        margin-top: 0;
-    }
-    .footer {
-        text-align: center;
-        margin-top: 20px;
-        padding: 10px;
-        background: linear-gradient(90deg, rgba(124, 58, 237, 0.05) 0%, rgba(236, 72, 153, 0.05) 100%);
-        border-radius: 12px;
-    }
+with gr.Blocks(title="SET Game Detector") as demo:
+    gr.HTML("""
+    <div style="text-align: center; margin-bottom: 1rem;">
+        <h1 style="margin-bottom: 0.5rem;">🎴 SET Game Detector</h1>
+        <p>Upload an image of a SET game board to find all valid sets</p>
+    </div>
+    """)
     
-    /* Responsive design for mobile */
-    @media (max-width: 600px) {
-        .app-header h1 {
-            font-size: 1.8rem;
-        }
-        .app-header p {
-            font-size: 0.9rem;
-        }
-    }
-    
-    /* Custom styling for buttons */
-    #find-sets-btn {
-        background: linear-gradient(90deg, #7C3AED 0%, #EC4899 100%);
-        color: white !important;
-    }
-    #find-sets-btn:hover {
-        opacity: 0.9;
-    }
-    
-    /* Image containers */
-    .image-container {
-        border-radius: 12px;
-        overflow: hidden;
-        box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
-    }
-    
-    /* Status box styling */
-    #status-box {
-        font-weight: 500;
-        border-radius: 8px;
-    }
-    """
-    
-    # Create the Gradio interface
-    with gr.Blocks(css=css, title="SET Game Detector") as demo:
-        # Header
-        gr.HTML("""
-        <div class="app-header">
-            <h1>🎴 SET Game Detector</h1>
-            <p>Upload an image of a SET board to find all valid sets</p>
-        </div>
-        """)
-        
-        # Model status display
-        model_status = gr.Textbox(
-            label="Model Status",
-            value=get_model_status(),
-            interactive=False
-        )
-        load_models_btn = gr.Button("🔄 Load Models", visible=not _MODELS_LOADED)
-        
-        # Main layout
-        with gr.Row():
-            with gr.Column():
-                # Fixed: Removed 'tool' parameter which is not supported in older Gradio versions
-                input_image = gr.Image(
-                    label="Upload SET Board Image",
-                    type="numpy",
-                    elem_id="input-image",
-                    elem_classes="image-container"
-                )
-                
-                with gr.Row():
-                    process_btn = gr.Button(
-                        "🔎 Find Sets", 
-                        variant="primary",
-                        elem_id="find-sets-btn",
-                        interactive=_MODELS_LOADED
-                    )
-                    clear_btn = gr.Button("🗑️ Clear", variant="secondary")
+    with gr.Row():
+        with gr.Column():
+            input_image = gr.Image(
+                label="Upload SET Board Image",
+                type="numpy"
+            )
             
-            with gr.Column():
-                output_image = gr.Image(
-                    label="Detected Sets",
-                    elem_id="output-image",
-                    elem_classes="image-container",
-                    interactive=False
-                )
-                status = gr.Textbox(
-                    label="Status", 
-                    placeholder="Upload an image and click 'Find Sets'",
-                    elem_id="status-box",
-                    interactive=False
-                )
-        
-        # Example images section - Create an examples directory for deployment
-        examples_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "examples")
-        os.makedirs(examples_dir, exist_ok=True)
-
-        # Add examples section - using simpler format for compatibility
-        gr.Examples(
-            examples=[
-                os.path.join(examples_dir, "set_example1.jpg"),
-                os.path.join(examples_dir, "set_example2.jpg")
-            ],
-            inputs=input_image
-        )
-        
-        # Footer with attribution
-        gr.HTML(
-            """
-            <div class="footer">
-                <p>SET Game Detector by <a href="https://github.com/omamitai" target="_blank">omamitai</a> | 
-                Gradio version adapted for Hugging Face Spaces</p>
-            </div>
-            """
-        )
+            find_sets_btn = gr.Button(
+                "🔎 Find Sets", 
+                variant="primary"
+            )
+            
+        with gr.Column():
+            output_image = gr.Image(
+                label="Detected Sets"
+            )
+            status = gr.Textbox(
+                label="Status",
+                value="Upload an image and click 'Find Sets'",
+                interactive=False
+            )
     
-    # Function bindings
-    load_models_btn.click(
-        fn=preload_models,
-        outputs=[model_status]
+    # Examples - simplified
+    gr.Examples(
+        examples=[
+            os.path.join(examples_dir, "set_example1.jpg"),
+            os.path.join(examples_dir, "set_example2.jpg")
+        ],
+        inputs=input_image
     )
     
-    process_btn.click(
-        fn=process_set_image,
+    # Function bindings inside the Blocks context
+    find_sets_btn.click(
+        fn=process_image,
         inputs=[input_image],
         outputs=[output_image, status]
     )
     
-    clear_btn.click(
-        fn=lambda: (None, "Ready for new image"),
-        outputs=[output_image, status]
-    )
-    
-    # Update button status when models are loaded
-    if _MODELS_LOADED:
-        process_btn.interactive = True
-        load_models_btn.visible = False
-    else:
-        # Try to load models on startup
-        try:
-            if load_all_models():
-                model_status.value = "Models loaded successfully! Ready to detect SETs."
-                process_btn.interactive = True
-                load_models_btn.visible = False
-        except Exception as e:
-            logger.error(f"Error preloading models: {str(e)}")
-    
-    return demo
+    gr.HTML("""
+    <div style="text-align: center; margin-top: 1rem; padding: 0.5rem; font-size: 0.8rem;">
+        <p>SET Game Detector by <a href="https://github.com/omamitai" target="_blank">omamitai</a> | 
+        Gradio version adapted for Hugging Face Spaces</p>
+    </div>
+    """)
 
 # =============================================================================
 # MAIN EXECUTION
 # =============================================================================
 if __name__ == "__main__":
-    # Initialize HF hub download for models when using Hugging Face Spaces
-    try:
-        from huggingface_hub import hf_hub_download
-    except ImportError:
-        logger.warning("huggingface_hub not available. Will try to use local models.")
-    
-    # Create examples directory if it doesn't exist
-    examples_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "examples")
-    os.makedirs(examples_dir, exist_ok=True)
-    
-    # Create the Gradio interface
-    demo = create_gradio_interface()
-    
     # Launch the app
     demo.queue().launch()