Create app.py

app.py

@@ -0,0 +1,206 @@
+import gradio as gr
+from PIL import Image
+import io
+import time
+
+def compress_image(image, target_format='webp', quality=85):
+    """
+    Compress and convert image to specified format
+    """
+    try:
+        if image is None:
+            return None, "No image provided"
+        
+        # Convert format name for PIL
+        save_format = 'JPEG' if target_format.lower() == 'jpg' else target_format.upper()
+        
+        # Create byte buffer
+        img_byte_arr = io.BytesIO()
+        
+        # Handle different format requirements
+        if target_format.lower() in ['jpg', 'jpeg']:
+            # Convert to RGB if necessary for JPEG
+            if image.mode in ('RGBA', 'LA', 'P'):
+                image = image.convert('RGB')
+            image.save(img_byte_arr, format='JPEG', quality=quality, optimize=True)
+        elif target_format.lower() == 'png':
+            # PNG doesn't use quality parameter
+            image.save(img_byte_arr, format='PNG', optimize=True)
+        elif target_format.lower() == 'webp':
+            image.save(img_byte_arr, format='WEBP', quality=quality, optimize=True)
+        
+        img_byte_arr.seek(0)
+        optimized_image = Image.open(img_byte_arr)
+        
+        return optimized_image, None
+        
+    except Exception as e:
+        return None, f"Compression error: {str(e)}"
+
+def calculate_file_size(image, format_name, quality=85):
+    """Calculate file size for given format and quality"""
+    try:
+        img_byte_arr = io.BytesIO()
+        save_format = 'JPEG' if format_name.lower() == 'jpg' else format_name.upper()
+        
+        if format_name.lower() in ['jpg', 'jpeg']:
+            if image.mode in ('RGBA', 'LA', 'P'):
+                image = image.convert('RGB')
+            image.save(img_byte_arr, format='JPEG', quality=quality, optimize=True)
+        elif format_name.lower() == 'png':
+            image.save(img_byte_arr, format='PNG', optimize=True)
+        elif format_name.lower() == 'webp':
+            image.save(img_byte_arr, format='WEBP', quality=quality, optimize=True)
+        
+        return len(img_byte_arr.getvalue())
+    except:
+        return 0
+
+def process_image(image, target_format, quality):
+    """Main processing function for Gradio interface"""
+    
+    if image is None:
+        return None, "Please upload an image first", None
+    
+    try:
+        # Get original image info
+        original_format = getattr(image, 'format', 'Unknown').lower()
+        if original_format == 'jpeg':
+            original_format = 'jpg'
+        
+        # Calculate original size
+        original_size = calculate_file_size(image, original_format, 95)  # Assume high quality for original
+        
+        # Process image
+        optimized_image, error = compress_image(image, target_format, quality)
+        
+        if error:
+            return None, error, None
+        
+        # Calculate optimized size
+        optimized_size = calculate_file_size(optimized_image, target_format, quality)
+        
+        # Calculate compression ratio
+        if original_size > 0:
+            compression_ratio = ((original_size - optimized_size) / original_size) * 100
+        else:
+            compression_ratio = 0
+        
+        # Create info text
+        info_text = f"""
+**Optimization Results:**
+- Original format: {original_format.upper()}
+- Target format: {target_format.upper()}
+- Original size: ~{original_size:,} bytes
+- Optimized size: ~{optimized_size:,} bytes
+- Compression: {compression_ratio:.1f}%
+- Quality setting: {quality}%
+"""
+        
+        return optimized_image, info_text, optimized_image
+        
+    except Exception as e:
+        return None, f"Processing error: {str(e)}", None
+
+def create_interface():
+    """Create and configure Gradio interface"""
+    
+    with gr.Blocks(title="Image Optimizer", theme=gr.themes.Soft()) as demo:
+        
+        gr.Markdown("# 🖼️ Image Optimizer")
+        gr.Markdown("Upload an image and optimize it by changing format and compression settings.")
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                # Input controls
+                input_image = gr.Image(
+                    label="Upload Image",
+                    type="pil",
+                    sources=["upload"],
+                    interactive=True
+                )
+                
+                target_format = gr.Dropdown(
+                    choices=["webp", "jpg", "png"],
+                    value="webp",
+                    label="Target Format",
+                    info="WebP usually provides best compression"
+                )
+                
+                quality = gr.Slider(
+                    minimum=10,
+                    maximum=95,
+                    value=85,
+                    step=5,
+                    label="Quality",
+                    info="Higher = better quality, larger file"
+                )
+                
+                optimize_btn = gr.Button(
+                    "🚀 Optimize Image",
+                    variant="primary",
+                    size="lg"
+                )
+            
+            with gr.Column(scale=1):
+                # Output
+                output_image = gr.Image(
+                    label="Optimized Image",
+                    type="pil",
+                    interactive=False
+                )
+                
+                info_output = gr.Markdown(
+                    label="Results",
+                    value="Upload an image and click optimize to see results."
+                )
+                
+                download_file = gr.File(
+                    label="Download Optimized Image",
+                    visible=False
+                )
+        
+        # Auto-update on parameter change
+        def update_preview(image, fmt, qual):
+            if image is not None:
+                return process_image(image, fmt, qual)
+            return None, "Upload an image to see preview", None
+        
+        # Event handlers
+        optimize_btn.click(
+            fn=process_image,
+            inputs=[input_image, target_format, quality],
+            outputs=[output_image, info_output, download_file]
+        )
+        
+        # Auto-update when parameters change (optional - remove if too slow)
+        target_format.change(
+            fn=update_preview,
+            inputs=[input_image, target_format, quality],
+            outputs=[output_image, info_output, download_file]
+        )
+        
+        quality.change(
+            fn=update_preview,
+            inputs=[input_image, target_format, quality],
+            outputs=[output_image, info_output, download_file]
+        )
+        
+        gr.Markdown("""
+        ### Tips:
+        - **WebP** format usually provides the best compression ratio
+        - **Quality 85%** is often a good balance between size and quality
+        - **PNG** is lossless but creates larger files
+        - **JPG** is good for photos, but doesn't support transparency
+        """)
+    
+    return demo
+
+if __name__ == "__main__":
+    demo = create_interface()
+    demo.launch(
+        server_name="0.0.0.0",  # For HuggingFace Spaces
+        server_port=7860,       # Standard port for HF Spaces
+        share=False,
+        show_error=True
+    )