test

app.py

@@ -1,10 +1,281 @@
+#!/usr/bin/env python3
+"""
+Gradio interface for multi-image processing with Qwen2-VL model
+"""
 import gradio as gr
+import os
+import sys
+from pathlib import Path
+import logging
+from typing import List, Dict, Any
+import asyncio
+from PIL import Image
+import io
+import base64
 
-with gr.Blocks(fill_height=True) as demo:
-    with gr.Sidebar():
-        gr.Markdown("# Inference Provider")
-        gr.Markdown("This Space showcases the Qwen/Qwen2-VL-7B-Instruct model, served by the hyperbolic API. Sign in with your Hugging Face account to use this API.")
-        button = gr.LoginButton("Sign in")
-    gr.load("models/Qwen/Qwen2-VL-7B-Instruct", accept_token=button, provider="hyperbolic")
+# Add the backend directory to Python path
+backend_dir = Path(__file__).parent
+sys.path.append(str(backend_dir))
+
+# Import the image processor
+try:
+    from app.services.ai.images.image_processor import ImageProcessor
+except ImportError as e:
+    print(f"Import error: {e}")
+    # Fallback for direct execution
+    ImageProcessor = None
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class GradioImageProcessor:
+    def __init__(self, use_api: bool = True, api_key: str = None):
+        """
+        Initialize the Gradio image processor
+        
+        Args:
+            use_api: Whether to use API mode (True) or local model (False)
+            api_key: Hugging Face API key for API mode
+        """
+        self.use_api = use_api
+        self.api_key = api_key or os.getenv("HF_API_KEY")
+        
+        if use_api and not self.api_key:
+            logger.warning("No API key provided. Please set HF_API_KEY environment variable.")
+        
+        # Initialize the image processor
+        if ImageProcessor:
+            try:
+                self.processor = ImageProcessor()
+                logger.info("Image processor initialized successfully")
+            except Exception as e:
+                logger.error(f"Failed to initialize image processor: {e}")
+                self.processor = None
+        else:
+            self.processor = None
+            logger.warning("ImageProcessor not available")
+    
+    def process_single_image(self, image: Image.Image, prompt: str = "Describe this image in detail.") -> str:
+        """
+        Process a single image with the given prompt
+        
+        Args:
+            image: PIL Image object
+            prompt: Text prompt for the model
+            
+        Returns:
+            Generated description
+        """
+        if not self.processor:
+            return "❌ Image processor not available"
+        
+        try:
+            # Convert PIL image to bytes for processing
+            img_byte_arr = io.BytesIO()
+            image.save(img_byte_arr, format='JPEG')
+            img_byte_arr = img_byte_arr.getvalue()
+            
+            # Create a temporary file-like object
+            img_io = io.BytesIO(img_byte_arr)
+            img_io.seek(0)
+            
+            # Process the image
+            result = self.processor._process_single_image(
+                image_data=img_io,
+                prompt_text=prompt
+            )
+            
+            return result
+            
+        except Exception as e:
+            logger.error(f"Error processing image: {e}")
+            return f"❌ Error processing image: {str(e)}"
+    
+    def process_multiple_images(self, images: List[Image.Image], prompt: str = "Describe each image in detail.") -> List[str]:
+        """
+        Process multiple images with the same prompt
+        
+        Args:
+            images: List of PIL Image objects
+            prompt: Text prompt for the model
+            
+        Returns:
+            List of generated descriptions
+        """
+        if not self.processor:
+            return ["❌ Image processor not available"] * len(images)
+        
+        results = []
+        for i, image in enumerate(images):
+            try:
+                result = self.process_single_image(image, prompt)
+                results.append(f"Image {i+1}: {result}")
+            except Exception as e:
+                logger.error(f"Error processing image {i+1}: {e}")
+                results.append(f"Image {i+1}: ❌ Error - {str(e)}")
+        
+        return results
+
+def create_gradio_interface():
+    """
+    Create the Gradio interface
+    """
+    # Initialize the processor
+    processor = GradioImageProcessor(use_api=True)
     
-demo.launch()
+    def process_images(images, prompt, api_key):
+        """
+        Process uploaded images
+        
+        Args:
+            images: List of uploaded images
+            prompt: User-provided prompt
+            api_key: Optional API key override
+            
+        Returns:
+            List of descriptions
+        """
+        if not images:
+            return "Please upload at least one image."
+        
+        # Update API key if provided
+        if api_key:
+            processor.api_key = api_key
+        
+        # Convert Gradio images to PIL Images
+        pil_images = []
+        for img in images:
+            if img is not None:
+                pil_images.append(Image.fromarray(img))
+        
+        if not pil_images:
+            return "No valid images found."
+        
+        # Process images
+        results = processor.process_multiple_images(pil_images, prompt)
+        
+        # Format results
+        if len(results) == 1:
+            return results[0]
+        else:
+            return "\n\n".join(results)
+    
+    # Create the interface
+    with gr.Blocks(
+        title="Multi-Image AI Processor",
+        theme=gr.themes.Soft(),
+        fill_height=True
+    ) as demo:
+        
+        gr.Markdown("# 🖼️ Multi-Image AI Processor")
+        gr.Markdown("Upload multiple images and get AI-generated descriptions using the Qwen2-VL model.")
+        
+        with gr.Row():
+            with gr.Column(scale=2):
+                # Image upload area
+                images_input = gr.File(
+                    file_count="multiple",
+                    file_types=["image"],
+                    label="Upload Images",
+                    height=300
+                )
+                
+                # Prompt input
+                prompt_input = gr.Textbox(
+                    label="Prompt",
+                    placeholder="Describe this image in detail...",
+                    value="Describe this image in detail.",
+                    lines=3
+                )
+                
+                # API key input (optional)
+                api_key_input = gr.Textbox(
+                    label="Hugging Face API Key (optional)",
+                    placeholder="hf_...",
+                    type="password",
+                    info="Leave empty to use environment variable"
+                )
+                
+                # Process button
+                process_btn = gr.Button(
+                    "🚀 Process Images",
+                    variant="primary",
+                    size="lg"
+                )
+            
+            with gr.Column(scale=2):
+                # Results area
+                results_output = gr.Textbox(
+                    label="Results",
+                    lines=10,
+                    max_lines=20,
+                    interactive=False
+                )
+        
+        # Examples
+        with gr.Accordion("Examples", open=False):
+            gr.Examples(
+                examples=[
+                    [
+                        ["Describe the architectural style and features of this building."],
+                        "Upload images of buildings to analyze their architectural style."
+                    ],
+                    [
+                        ["What are the key features and amenities shown in this property?"],
+                        "Upload property images to get detailed descriptions of features and amenities."
+                    ],
+                    [
+                        ["Describe the interior design and layout of this space."],
+                        "Upload interior photos to get detailed descriptions of design and layout."
+                    ]
+                ],
+                inputs=[prompt_input],
+                outputs=[results_output],
+                label="Example Prompts"
+            )
+        
+        # Footer
+        gr.Markdown("---")
+        gr.Markdown("""
+        **How to use:**
+        1. Upload one or more images
+        2. Enter a prompt describing what you want to know about the images
+        3. Optionally provide your Hugging Face API key
+        4. Click "Process Images" to get AI-generated descriptions
+        
+        **Tips:**
+        - Use specific prompts for better results
+        - The model works best with clear, high-quality images
+        - You can process multiple images at once
+        """)
+        
+        # Connect the process button
+        process_btn.click(
+            fn=process_images,
+            inputs=[images_input, prompt_input, api_key_input],
+            outputs=[results_output]
+        )
+    
+    return demo
+
+def main():
+    """
+    Main function to launch the Gradio app
+    """
+    print("🚀 Starting Multi-Image AI Processor...")
+    
+    # Create the interface
+    demo = create_gradio_interface()
+    
+    # Launch the app
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+        show_error=True,
+        show_tips=True
+    )
+
+if __name__ == "__main__":
+    main()