Delete app.py

app.py

@@ -1,206 +0,0 @@
-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
-    )