Update app.py

app.py

@@ -1,206 +1,331 @@
 import gradio as gr
-import PIL.Image as Image
-import io
 import base64
 import json
-from typing import Union
+import requests
+from io import BytesIO
+from PIL import Image
+import traceback
+from gradio_client import Client
+from typing import Optional, Tuple, Dict, Any
 
-def analyze_image(image: Image.Image) -> str:
-    """
-    Analyze an image and return detailed information about it.
+class MCPImageAnalyzer:
+    def __init__(self, space_url: str = "https://chris4k-mcp-images.hf.space"):
+        """Initialize the MCP Image Analyzer client."""
+        self.space_url = space_url.rstrip('/')
+        self.client = None
+        self.connection_status = "Disconnected"
+        
+    def connect(self) -> Tuple[str, str]:
+        """Connect to the MCP server."""
+        try:
+            self.client = Client(self.space_url)
+            # Test connection by checking if we can get the client info
+            self.connection_status = "Connected ✅"
+            return f"✅ Successfully connected to {self.space_url}", "success"
+        except Exception as e:
+            self.connection_status = "Connection Failed ❌"
+            return f"❌ Failed to connect to {self.space_url}: {str(e)}", "error"
     
-    Args:
-        image: The image to analyze (can be base64 string or file upload)
+    def analyze_image(self, image: Image.Image) -> Dict[str, Any]:
+        """Analyze an image using the MCP server."""
+        if not self.client:
+            return {"error": "Not connected to MCP server. Please connect first."}
+        
+        if image is None:
+            return {"error": "No image provided"}
+        
+        try:
+            result = self.client.predict(
+                image=image,
+                api_name="/analyze_image"
+            )
+            return json.loads(result) if isinstance(result, str) else result
+        except Exception as e:
+            return {"error": f"Analysis failed: {str(e)}"}
     
-    Returns:
-        str: JSON string with image analysis including dimensions, format, mode, and orientation
-    """
-    if image is None:
-        return json.dumps({"error": "No image provided"})
-    
-    try:
-        # Get image properties
-        width, height = image.size
-        format_type = image.format or "Unknown"
-        mode = image.mode
-        orientation = "Portrait" if height > width else "Landscape" if width > height else "Square"
+    def get_orientation(self, image: Image.Image) -> str:
+        """Get image orientation using the MCP server."""
+        if not self.client:
+            return "❌ Not connected to MCP server"
+        
+        if image is None:
+            return "❌ No image provided"
         
-        # Calculate aspect ratio
-        aspect_ratio = round(width / height, 2) if height > 0 else 0
+        try:
+            result = self.client.predict(
+                image=image,
+                api_name="/get_image_orientation"
+            )
+            return f"📐 Orientation: {result}"
+        except Exception as e:
+            return f"❌ Error: {str(e)}"
+    
+    def analyze_colors(self, image: Image.Image) -> str:
+        """Analyze colors using the MCP server."""
+        if not self.client:
+            return "❌ Not connected to MCP server"
         
-        # Get color information
-        colors = image.getcolors(maxcolors=256*256*256)
-        dominant_colors = len(colors) if colors else "Many"
+        if image is None:
+            return "❌ No image provided"
         
-        analysis = {
-            "dimensions": {"width": width, "height": height},
-            "format": format_type,
-            "mode": mode,
-            "orientation": orientation,
-            "aspect_ratio": aspect_ratio,
-            "approximate_colors": dominant_colors,
-            "file_info": f"{width}x{height} {format_type} image in {mode} mode"
-        }
+        try:
+            result = self.client.predict(
+                image=image,
+                api_name="/count_colors"
+            )
+            return f"🎨 Color Analysis:\n{result}"
+        except Exception as e:
+            return f"❌ Error: {str(e)}"
+    
+    def extract_text_info(self, image: Image.Image) -> Dict[str, Any]:
+        """Extract text info using the MCP server."""
+        if not self.client:
+            return {"error": "Not connected to MCP server"}
         
-        return json.dumps(analysis, indent=2)
+        if image is None:
+            return {"error": "No image provided"}
         
-    except Exception as e:
-        return json.dumps({"error": f"Error analyzing image: {str(e)}"})
+        try:
+            result = self.client.predict(
+                image=image,
+                api_name="/extract_text_info"
+            )
+            return json.loads(result) if isinstance(result, str) else result
+        except Exception as e:
+            return {"error": f"Text analysis failed: {str(e)}"}
+
+# Initialize the analyzer
+analyzer = MCPImageAnalyzer()
 
-def get_image_orientation(image: Image.Image) -> str:
-    """
-    Determine if an image is portrait, landscape, or square.
+def create_sample_images():
+    """Create sample test images."""
+    samples = {}
     
-    Args:
-        image: The image to check orientation
+    # Red rectangle
+    img1 = Image.new('RGB', (400, 300), color='red')
+    samples["Red Rectangle (400x300)"] = img1
     
-    Returns:
-        str: "Portrait", "Landscape", or "Square"
-    """
-    if image is None:
-        return "No image provided"
-    
-    try:
-        width, height = image.size
-        if height > width:
-            return "Portrait"
-        elif width > height:
-            return "Landscape"
-        else:
-            return "Square"
-    except Exception as e:
-        return f"Error: {str(e)}"
-
-def count_colors(image: Image.Image) -> str:
-    """
-    Count the approximate number of unique colors in an image.
+    # Blue square
+    img2 = Image.new('RGB', (300, 300), color='blue')
+    samples["Blue Square (300x300)"] = img2
     
-    Args:
-        image: The image to analyze for color count
+    # Colorful gradient
+    img3 = Image.new('RGB', (200, 400))
+    pixels = img3.load()
+    for i in range(200):
+        for j in range(400):
+            pixels[i, j] = (i % 256, j % 256, (i + j) % 256)
+    samples["Colorful Gradient (200x400)"] = img3
     
-    Returns:
-        str: Description of color count and dominant color information
-    """
+    # Simple pattern
+    img4 = Image.new('RGB', (100, 100), color='white')
+    pixels = img4.load()
+    for i in range(100):
+        for j in range(100):
+            if (i // 10 + j // 10) % 2:
+                pixels[i, j] = (0, 0, 0)
+    samples["Checkerboard Pattern (100x100)"] = img4
+    
+    return samples
+
+def connect_to_server():
+    """Connect to the MCP server."""
+    status, status_type = analyzer.connect()
+    if status_type == "success":
+        return status, gr.update(variant="primary"), gr.update(visible=True)
+    else:
+        return status, gr.update(variant="stop"), gr.update(visible=False)
+
+def run_comprehensive_analysis(image):
+    """Run all analysis functions on the uploaded image."""
     if image is None:
-        return "No image provided"
+        return "❌ Please upload an image first", "", "", ""
     
-    try:
-        # Convert to RGB if not already
-        if image.mode != 'RGB':
-            image = image.convert('RGB')
-        
-        # Get colors (limit to prevent memory issues)
-        colors = image.getcolors(maxcolors=256*256*256)
-        
-        if colors is None:
-            return "Image has more than 16.7 million unique colors"
-        
-        # Sort by frequency
-        colors.sort(key=lambda x: x[0], reverse=True)
-        
-        # Get top 3 colors
-        top_colors = colors[:3]
-        color_info = []
-        
-        for count, color in top_colors:
-            if isinstance(color, tuple) and len(color) >= 3:
-                r, g, b = color[:3]
-                hex_color = f"#{r:02x}{g:02x}{b:02x}"
-                percentage = round((count / sum(c[0] for c in colors)) * 100, 1)
-                color_info.append(f"RGB{color} ({hex_color}) - {percentage}%")
-        
-        result = f"Total unique colors: {len(colors)}\n"
-        result += "Top colors by frequency:\n" + "\n".join(color_info)
-        
-        return result
-        
-    except Exception as e:
-        return f"Error analyzing colors: {str(e)}"
+    # Run all analyses
+    analysis = analyzer.analyze_image(image)
+    orientation = analyzer.get_orientation(image)
+    colors = analyzer.analyze_colors(image)
+    text_info = analyzer.extract_text_info(image)
+    
+    # Format results
+    analysis_result = json.dumps(analysis, indent=2) if isinstance(analysis, dict) else str(analysis)
+    text_result = json.dumps(text_info, indent=2) if isinstance(text_info, dict) else str(text_info)
+    
+    return analysis_result, orientation, colors, text_result
+
+def load_sample_image(sample_name):
+    """Load a sample image."""
+    samples = create_sample_images()
+    return samples.get(sample_name, None)
 
-def extract_text_info(image: Image.Image) -> str:
-    """
-    Extract basic information about text-like content in an image.
+# Create the Gradio interface
+with gr.Blocks(title="MCP Image Analysis Test Client", theme=gr.themes.Soft()) as demo:
+    gr.HTML("""
+    <div style="text-align: center; padding: 20px;">
+        <h1>🖼️ MCP Image Analysis Test Client</h1>
+        <p>Test your Gradio MCP Image Analysis server with this interactive client</p>
+        <p><strong>Server:</strong> <code>https://chris4k-mcp-images.hf.space</code></p>
+    </div>
+    """)
     
-    Args:
-        image: The image to analyze for text content
+    # Connection section
+    with gr.Row():
+        with gr.Column():
+            gr.Markdown("## 🔌 Connection")
+            connect_btn = gr.Button("Connect to MCP Server", variant="primary", size="lg")
+            connection_status = gr.Textbox(
+                label="Connection Status", 
+                value="Not connected", 
+                interactive=False
+            )
     
-    Returns:
-        str: Basic information about potential text content
-    """
-    if image is None:
-        return "No image provided"
+    # Main testing interface (initially hidden)
+    main_interface = gr.Column(visible=False)
     
-    try:
-        # Convert to grayscale for analysis
-        gray = image.convert('L')
+    with main_interface:
+        gr.Markdown("## 🧪 Image Analysis Testing")
         
-        # Get image statistics
-        extrema = gray.getextrema()
-        
-        # Simple heuristics for text detection
-        contrast = extrema[1] - extrema[0]
+        with gr.Row():
+            with gr.Column(scale=1):
+                gr.Markdown("### 📤 Upload Image")
+                image_input = gr.Image(
+                    label="Upload Image for Analysis",
+                    type="pil",
+                    height=300
+                )
+                
+                gr.Markdown("### 🎯 Quick Test Samples")
+                sample_dropdown = gr.Dropdown(
+                    choices=list(create_sample_images().keys()),
+                    label="Load Sample Image",
+                    value=None
+                )
+                load_sample_btn = gr.Button("Load Sample", size="sm")
+                
+                gr.Markdown("### 🚀 Run Analysis")
+                analyze_btn = gr.Button("Analyze Image", variant="primary", size="lg")
+                
+            with gr.Column(scale=2):
+                gr.Markdown("### 📊 Analysis Results")
+                
+                with gr.Tabs():
+                    with gr.Tab("📈 Comprehensive Analysis"):
+                        analysis_output = gr.Code(
+                            label="Full Image Analysis",
+                            language="json",
+                            lines=15
+                        )
+                    
+                    with gr.Tab("📐 Orientation"):
+                        orientation_output = gr.Textbox(
+                            label="Image Orientation",
+                            lines=3
+                        )
+                    
+                    with gr.Tab("🎨 Color Analysis"):
+                        color_output = gr.Textbox(
+                            label="Color Information",
+                            lines=10
+                        )
+                    
+                    with gr.Tab("📝 Text Detection"):
+                        text_output = gr.Code(
+                            label="Text Analysis",
+                            language="json",
+                            lines=10
+                        )
         
-        analysis = {
-            "image_mode": image.mode,
-            "grayscale_range": f"{extrema[0]} to {extrema[1]}",
-            "contrast_level": "High" if contrast > 200 else "Medium" if contrast > 100 else "Low",
-            "potential_text": "Likely contains text" if contrast > 150 else "May contain text" if contrast > 100 else "Unlikely to contain text",
-            "note": "This is a basic analysis. For proper OCR, use specialized text extraction tools."
-        }
+        # Individual tool testing section
+        gr.Markdown("## 🔧 Individual Tool Testing")
         
-        return json.dumps(analysis, indent=2)
+        with gr.Row():
+            with gr.Column():
+                gr.Markdown("### Single Tool Tests")
+                single_image = gr.Image(label="Image for Single Tool Test", type="pil", height=200)
+                
+                with gr.Row():
+                    orient_btn = gr.Button("Check Orientation", size="sm")
+                    color_btn = gr.Button("Analyze Colors", size="sm")
+                
+                single_result = gr.Textbox(
+                    label="Single Tool Result",
+                    lines=5
+                )
         
-    except Exception as e:
-        return f"Error analyzing for text: {str(e)}"
-
-# Create the Gradio interface
-with gr.Blocks(title="Image Analysis MCP Server") as demo:
-    gr.Markdown("""
-    # Image Analysis MCP Server
-    
-    This Gradio app serves as an MCP server that can analyze images sent from Claude or other MCP clients.
-    
-    **Available Tools:**
-    - `analyze_image`: Get comprehensive image analysis (dimensions, format, colors, etc.)
-    - `get_image_orientation`: Check if image is portrait, landscape, or square
-    - `count_colors`: Analyze color information and dominant colors
-    - `extract_text_info`: Basic analysis for potential text content
-    
-    **Usage with Claude Desktop:**
-    1. Deploy this to HuggingFace Spaces
-    2. Add the MCP configuration to Claude Desktop
-    3. Send images to Claude and ask it to analyze them using these tools
-    """)
+        # Usage examples and help
+        with gr.Accordion("📖 Usage Guide & Examples", open=False):
+            gr.Markdown("""
+            ## How to Use This Test Client
+            
+            1. **Connect**: Click "Connect to MCP Server" to establish connection
+            2. **Upload Image**: Use the image upload area or load a sample image
+            3. **Analyze**: Click "Analyze Image" to run all analysis tools
+            4. **Review Results**: Check different tabs for specific analysis results
+            
+            ## Available Analysis Tools
+            
+            - **📈 Comprehensive Analysis**: Complete image metadata (dimensions, format, colors, etc.)
+            - **📐 Orientation Detection**: Portrait, Landscape, or Square
+            - **🎨 Color Analysis**: Dominant colors and color count
+            - **📝 Text Detection**: Basic text presence analysis
+            
+            ## Sample Images
+            
+            Try the built-in sample images to test different scenarios:
+            - Different orientations (portrait vs landscape)
+            - Various color schemes
+            - Different dimensions and formats
+            
+            ## Testing with Claude Desktop
+            
+            This same MCP server can be used with Claude Desktop by adding this configuration:
+            
+            ```json
+            {
+              "mcpServers": {
+                "image-analysis": {
+                  "url": "https://chris4k-mcp-images.hf.space/gradio_api/mcp/sse"
+                }
+              }
+            }
+            ```
+            """)
     
-    # Create interface for each function (these will be exposed as MCP tools)
-    with gr.Tab("Image Analysis"):
-        with gr.Row():
-            img_input1 = gr.Image(type="pil", label="Upload Image")
-            analysis_output = gr.JSON(label="Analysis Result")
-        analyze_btn = gr.Button("Analyze Image")
-        analyze_btn.click(analyze_image, inputs=[img_input1], outputs=[analysis_output])
+    # Event handlers
+    connect_btn.click(
+        connect_to_server,
+        outputs=[connection_status, connect_btn, main_interface]
+    )
     
-    with gr.Tab("Orientation Check"):
-        with gr.Row():
-            img_input2 = gr.Image(type="pil", label="Upload Image")
-            orientation_output = gr.Textbox(label="Orientation")
-        orientation_btn = gr.Button("Check Orientation")
-        orientation_btn.click(get_image_orientation, inputs=[img_input2], outputs=[orientation_output])
+    load_sample_btn.click(
+        load_sample_image,
+        inputs=[sample_dropdown],
+        outputs=[image_input]
+    )
     
-    with gr.Tab("Color Analysis"):
-        with gr.Row():
-            img_input3 = gr.Image(type="pil", label="Upload Image")
-            color_output = gr.Textbox(label="Color Analysis", lines=10)
-        color_btn = gr.Button("Analyze Colors")
-        color_btn.click(count_colors, inputs=[img_input3], outputs=[color_output])
+    analyze_btn.click(
+        run_comprehensive_analysis,
+        inputs=[image_input],
+        outputs=[analysis_output, orientation_output, color_output, text_output]
+    )
     
-    with gr.Tab("Text Detection"):
-        with gr.Row():
-            img_input4 = gr.Image(type="pil", label="Upload Image")
-            text_output = gr.JSON(label="Text Analysis")
-        text_btn = gr.Button("Analyze for Text")
-        text_btn.click(extract_text_info, inputs=[img_input4], outputs=[text_output])
+    # Individual tool tests
+    orient_btn.click(
+        analyzer.get_orientation,
+        inputs=[single_image],
+        outputs=[single_result]
+    )
+    
+    color_btn.click(
+        analyzer.analyze_colors,
+        inputs=[single_image],
+        outputs=[single_result]
+    )
 
+# Launch the app
 if __name__ == "__main__":
-    # Launch with MCP server enabled
-    demo.launch(mcp_server=True, share=True)
+    demo.launch(
+        debug=True,
+        share=True, 
+        show_error=True
+    )