Update app.py

app.py

@@ -1,353 +1,193 @@
 import gradio as gr
+from PIL import Image
+import io
+import time
 import tempfile
-import os
 from pathlib import Path
 import zipfile
-import time
-from PIL import Image
-import io
 
-class ImageCompressor:
-    def __init__(self):
-        pass
-        
-    def compress(self, input_path, output_path, method="webp", quality=75):
-        """Main compression entry point"""
-        img = Image.open(input_path)
-        original_size = Path(input_path).stat().st_size
-        
-        # Smart resize if image is huge (for HF memory limits)
-        img = self.smart_resize(img)
-        
-        # Always use .webp or .png extension
-        output_file = Path(output_path)
-        
-        if method == "png_optimized":
-            output_file = output_file.with_suffix('.png')
-            compressed = self._compress_png_optimized(img)
-        elif method == "png_quantized":
-            output_file = output_file.with_suffix('.png')
-            compressed = self._compress_png_quantized(img)
-        elif method == "jpeg":
-            output_file = output_file.with_suffix('.jpg')
-            compressed = self._compress_jpeg(img, quality)
-        else:
-            # Default to WebP
-            output_file = output_file.with_suffix('.webp')
-            compressed = self._compress_webp(img, quality)
-        
-        # Save compressed image
-        with open(output_file, 'wb') as f:
-            f.write(compressed)
-        
-        compressed_size = output_file.stat().st_size
-        ratio = (1 - compressed_size / original_size) * 100
-        
-        return str(output_file), ratio
+def compress_image(file, quality=75, format_type="webp"):
+    """Simple image compression function"""
+    if file is None:
+        return None, "Please upload an image"
     
-    def _compress_webp(self, img, quality=80):
-        """Standard WebP compression"""
-        output = io.BytesIO()
-        
-        # Handle transparency
-        if img.mode == 'RGBA':
-            img.save(output, format='WEBP', quality=quality, method=4, lossless=False)
-        else:
-            img.save(output, format='WEBP', quality=quality, method=4)
+    try:
+        # Open image
+        img = Image.open(file.name)
+        original_size = Path(file.name).stat().st_size / 1024
         
-        return output.getvalue()
-    
-    def _compress_png_optimized(self, img):
-        """PNG with optimization"""
-        output = io.BytesIO()
-        img.save(output, format='PNG', optimize=True)
-        return output.getvalue()
-    
-    def _compress_png_quantized(self, img, colors=128):
-        """Heavy PNG quantization for graphics"""
+        # Compress to selected format
         output = io.BytesIO()
         
-        # Aggressive color reduction
-        if img.mode in ('RGB', 'RGBA'):
-            img_quantized = img.quantize(colors=colors, method=Image.FASTOCTREE)
-            
-            # Convert back to RGB for better compatibility
-            if img_quantized.mode == 'P':
-                img_quantized = img_quantized.convert('RGB')
-            
-            img_quantized.save(output, format='PNG', optimize=True)
-        else:
+        if format_type == "webp":
+            img.save(output, format='WEBP', quality=quality, method=4)
+            extension = ".webp"
+        elif format_type == "jpeg":
+            if img.mode in ('RGBA', 'LA', 'P'):
+                # Convert to RGB for JPEG
+                rgb_img = Image.new('RGB', img.size, (255, 255, 255))
+                rgb_img.paste(img, mask=img.split()[-1] if img.mode == 'RGBA' else None)
+                img = rgb_img
+            img.save(output, format='JPEG', quality=quality, optimize=True)
+            extension = ".jpg"
+        else:  # png
             img.save(output, format='PNG', optimize=True)
+            extension = ".png"
         
-        return output.getvalue()
-    
-    def _compress_jpeg(self, img, quality=85):
-        """JPEG compression"""
-        output = io.BytesIO()
-        
-        # Convert to RGB if needed
-        if img.mode in ('RGBA', 'LA', 'P'):
-            # Create white background for transparency
-            if img.mode == 'RGBA':
-                background = Image.new('RGB', img.size, (255, 255, 255))
-                background.paste(img, mask=img.split()[-1])
-                img = background
-            else:
-                img = img.convert('RGB')
-        
-        img.save(output, format='JPEG', quality=quality, optimize=True, progressive=True)
-        return output.getvalue()
-    
-    def smart_resize(self, img, max_dimension=2048):
-        """Intelligently resize if image is too large"""
-        width, height = img.size
-        max_dim = max(width, height)
-        
-        if max_dim > max_dimension:
-            scale = max_dimension / max_dim
-            new_size = (int(width * scale), int(height * scale))
-            return img.resize(new_size, Image.Resampling.LANCZOS)
-        return img
-
-def simple_analyze(image_path):
-    """Simple image type detection without OpenCV (for HF compatibility)"""
-    try:
-        img = Image.open(image_path)
-        
-        # Check for transparency
-        has_transparency = img.mode in ('RGBA', 'LA', 'P')
+        output.seek(0)
+        compressed_size = len(output.getvalue()) / 1024
+        saved_percent = (1 - compressed_size / original_size) * 100
         
-        # Check if likely a screenshot (based on file size vs dimensions)
-        width, height = img.size
-        file_size = Path(image_path).stat().st_size
-        estimated_raw_size = width * height * 3  # RGB bytes
-        compression_ratio = estimated_raw_size / file_size if file_size > 0 else 0
-        
-        if has_transparency:
-            return "graphic_with_transparency", "png_optimized"
-        elif compression_ratio < 5:  # Highly compressed already
-            return "photo", "webp"
-        else:
-            return "screenshot_or_text", "webp"
-    except:
-        return "photo", "webp"
-
-# Initialize compressor
-compressor = ImageCompressor()
-
-def compress_single_image(file, preset="auto"):
-    """Compress a single image"""
-    if file is None:
-        return None, "No file uploaded", None
-    
-    try:
-        input_path = Path(file.name)
+        # Save to temp file for download
+        temp_path = tempfile.NamedTemporaryFile(delete=False, suffix=extension)
+        temp_path.write(output.getvalue())
+        temp_path.close()
         
-        # Determine method based on preset
-        if preset == "auto":
-            content_type, method = simple_analyze(input_path)
-            quality = 80
-        elif preset == "extreme":
-            method = "webp"
-            quality = 60
-        elif preset == "high_quality":
-            method = "webp"
-            quality = 90
-        elif preset == "png_optimized":
-            method = "png_optimized"
-            quality = 85
-        else:
-            method = "webp"
-            quality = 75
+        info = f"""✅ Success!
         
-        # Create output path in temp directory
-        with tempfile.TemporaryDirectory() as temp_dir:
-            output_path = Path(temp_dir) / f"compressed_{input_path.stem}"
-            
-            # Compress
-            start_time = time.time()
-            result_path, ratio = compressor.compress(
-                input_path, 
-                output_path, 
-                method=method,
-                quality=quality
-            )
-            compression_time = time.time() - start_time
-            
-            # Calculate metrics
-            original_size = input_path.stat().st_size / 1024
-            compressed_size = Path(result_path).stat().st_size / 1024
-            
-            info = f"""
-✅ Compression Complete!
-
 Original: {original_size:.1f} KB
 Compressed: {compressed_size:.1f} KB
-Saved: {ratio:.1f}%
-Time: {compression_time:.2f}s
-Method: {method}
-Quality: {quality}
-            """
-            
-            # Copy to persistent location for download
-            persistent_path = Path("/tmp") / f"{input_path.stem}_compressed_{int(time.time())}{Path(result_path).suffix}"
-            import shutil
-            shutil.copy(result_path, persistent_path)
-            
-            return str(persistent_path), info, None
+Saved: {saved_percent:.1f}%
+Format: {format_type.upper()}
+Quality: {quality}"""
+        
+        return temp_path.name, info
         
     except Exception as e:
-        return None, f"❌ Error: {str(e)}", None
+        return None, f"❌ Error: {str(e)}"
 
-def compress_batch(files, preset="auto"):
-    """Compress multiple images"""
+def compress_batch(files, quality=75, format_type="webp"):
+    """Batch compression"""
     if not files:
-        return None, "No files uploaded"
+        return None, "Please upload files"
     
-    compressed_files = []
+    compressed_paths = []
     total_saved = 0
     
     with tempfile.TemporaryDirectory() as temp_dir:
-        for idx, file in enumerate(files):
+        for file in files:
             try:
-                input_path = Path(file.name)
-                output_path = Path(temp_dir) / f"compressed_{input_path.stem}_{idx}"
+                img = Image.open(file.name)
+                original_size = Path(file.name).stat().st_size / 1024
+                
+                output = io.BytesIO()
+                if format_type == "webp":
+                    img.save(output, format='WEBP', quality=quality)
+                    ext = ".webp"
+                elif format_type == "jpeg":
+                    if img.mode in ('RGBA', 'LA', 'P'):
+                        rgb_img = Image.new('RGB', img.size, (255, 255, 255))
+                        rgb_img.paste(img, mask=img.split()[-1] if img.mode == 'RGBA' else None)
+                        img = rgb_img
+                    img.save(output, format='JPEG', quality=quality)
+                    ext = ".jpg"
+                else:
+                    img.save(output, format='PNG', optimize=True)
+                    ext = ".png"
                 
-                # Auto-detect method
-                content_type, method = simple_analyze(input_path)
-                quality = 80
+                output.seek(0)
+                compressed_size = len(output.getvalue()) / 1024
+                saved = (1 - compressed_size / original_size) * 100
+                total_saved += saved
                 
-                result_path, ratio = compressor.compress(input_path, output_path, method=method, quality=quality)
-                compressed_files.append(result_path)
-                total_saved += ratio
+                # Save file
+                temp_file = Path(temp_dir) / f"compressed_{Path(file.name).stem}{ext}"
+                with open(temp_file, 'wb') as f:
+                    f.write(output.getvalue())
+                compressed_paths.append(temp_file)
                 
             except Exception as e:
-                print(f"Error compressing {file.name}: {e}")
+                print(f"Error: {e}")
         
-        if not compressed_files:
+        if not compressed_paths:
             return None, "No files could be compressed"
         
         # Create ZIP
         zip_path = Path(temp_dir) / "compressed_images.zip"
         with zipfile.ZipFile(zip_path, 'w') as zipf:
-            for cf in compressed_files:
-                zipf.write(cf, Path(cf).name)
+            for path in compressed_paths:
+                zipf.write(path, path.name)
         
         # Copy to persistent location
-        persistent_zip = Path("/tmp") / f"batch_compressed_{int(time.time())}.zip"
+        final_zip = Path("/tmp") / f"batch_{int(time.time())}.zip"
         import shutil
-        shutil.copy(zip_path, persistent_zip)
+        shutil.copy(zip_path, final_zip)
         
-        avg_saving = total_saved / len(compressed_files) if compressed_files else 0
-        info = f"✅ Compressed {len(compressed_files)} files\nAverage saving: {avg_saving:.1f}%"
+        avg_saved = total_saved / len(compressed_paths)
+        info = f"✅ Compressed {len(compressed_paths)} files\nAverage saving: {avg_saved:.1f}%"
         
-        return str(persistent_zip), info
+        return str(final_zip), info
 
-def compare_images(original, compressed):
-    """Create side-by-side comparison"""
-    if original is None or compressed is None:
-        return None
-    
-    try:
-        # Handle both file paths and file objects
-        if hasattr(original, 'name'):
-            orig_path = original.name
-        else:
-            orig_path = original
-            
-        if hasattr(compressed, 'name'):
-            comp_path = compressed.name
-        else:
-            comp_path = compressed
-        
-        orig_img = Image.open(orig_path)
-        comp_img = Image.open(comp_path)
-        
-        # Resize to same height for comparison
-        target_height = 400
-        ratio = target_height / orig_img.size[1]
-        new_width = int(orig_img.size[0] * ratio)
-        orig_img = orig_img.resize((new_width, target_height), Image.Resampling.LANCZOS)
-        comp_img = comp_img.resize((new_width, target_height), Image.Resampling.LANCZOS)
-        
-        # Create comparison (side by side)
-        total_width = new_width * 2
-        comparison = Image.new('RGB', (total_width, target_height))
-        comparison.paste(orig_img, (0, 0))
-        comparison.paste(comp_img, (new_width, 0))
-        
-        # Save to temp file
-        temp_compare = tempfile.NamedTemporaryFile(delete=False, suffix='.png')
-        comparison.save(temp_compare.name)
-        
-        return temp_compare.name
-    except Exception as e:
-        print(f"Comparison error: {e}")
-        return None
-
-# Create Gradio interface
-with gr.Blocks(title="AI Image Compressor", theme=gr.themes.Soft()) as demo:
+# Create interface
+with gr.Blocks(title="Image Compressor", theme=gr.themes.Soft()) as demo:
     gr.Markdown("""
-    # 🚀 AI-Powered Image Compressor
+    # 🚀 Image Compressor
     
-    ### Better than imagecompressor.com - Completely free, runs entirely in your browser!
+    **Simple, fast, and private - all processing happens in your browser!**
     
-    **Features:**
-    - 🎯 **Smart compression** - Automatically detects image type
-    - 📦 **WebP support** - 25-35% smaller than JPEG
-    - 🔄 **Batch processing** - Compress up to 10 images at once
-    - 📊 **Real metrics** - See exact savings
-    - 💯 **Lossless options** - Perfect for graphics
-    - 🔒 **Privacy first** - No images stored on server
+    ### Features:
+    - Compress JPEG, PNG, WebP
+    - Batch processing with ZIP download
+    - Adjustable quality
+    - No uploads to server
     """)
     
     with gr.Tabs():
-        with gr.TabItem("📸 Single Image"):
+        with gr.TabItem("Single Image"):
             with gr.Row():
                 with gr.Column():
-                    input_image = gr.File(label="Upload Image", file_types=["image"])
-                    preset = gr.Radio(
-                        choices=["auto", "extreme", "high_quality", "png_optimized"],
-                        value="auto",
-                        label="Compression Preset",
-                        info="auto = automatically choose best method"
+                    input_file = gr.File(label="Upload Image", file_types=["image"])
+                    format_choice = gr.Radio(
+                        choices=["webp", "jpeg", "png"],
+                        value="webp",
+                        label="Output Format"
+                    )
+                    quality_slider = gr.Slider(
+                        minimum=30, 
+                        maximum=100, 
+                        value=75, 
+                        label="Quality (higher = better quality, larger file)"
                     )
-                    compress_btn = gr.Button("Compress!", variant="primary", size="lg")
+                    compress_btn = gr.Button("Compress", variant="primary")
                 
                 with gr.Column():
-                    output_image = gr.File(label="📥 Download Compressed Image")
-                    info_text = gr.Textbox(label="Compression Info", lines=8)
-            
-            with gr.Row():
-                compare_btn = gr.Button("🔄 Compare Original vs Compressed")
-                comparison = gr.Image(label="Left: Original | Right: Compressed")
-        
-        with gr.TabItem("📦 Batch Processing"):
-            batch_files = gr.File(label="Upload Multiple Images", file_types=["image"], file_count="multiple")
-            batch_info_text = gr.Markdown("### Upload up to 10 images for batch compression")
-            batch_btn = gr.Button("Compress All", variant="primary", size="lg")
-            batch_output = gr.File(label="📥 Download ZIP with Compressed Images")
-            batch_info = gr.Textbox(label="Batch Info", lines=5)
+                    output_file = gr.File(label="Download Compressed Image")
+                    info_text = gr.Textbox(label="Results", lines=8)
+        
+        with gr.TabItem("Batch Processing"):
+            batch_files = gr.File(
+                label="Upload Multiple Images", 
+                file_types=["image"], 
+                file_count="multiple"
+            )
+            batch_format = gr.Radio(
+                choices=["webp", "jpeg", "png"],
+                value="webp",
+                label="Output Format"
+            )
+            batch_quality = gr.Slider(
+                minimum=30, 
+                maximum=100, 
+                value=75, 
+                label="Quality"
+            )
+            batch_btn = gr.Button("Compress All", variant="primary")
+            batch_output = gr.File(label="Download ZIP")
+            batch_info = gr.Textbox(label="Results", lines=5)
     
     # Connect functions
     compress_btn.click(
-        compress_single_image,
-        inputs=[input_image, preset],
-        outputs=[output_image, info_text, comparison]
-    )
-    
-    compare_btn.click(
-        compare_images,
-        inputs=[input_image, output_image],
-        outputs=[comparison]
+        compress_image,
+        inputs=[input_file, quality_slider, format_choice],
+        outputs=[output_file, info_text]
     )
     
     batch_btn.click(
         compress_batch,
-        inputs=[batch_files, batch_preset],
+        inputs=[batch_files, batch_quality, batch_format],
         outputs=[batch_output, batch_info]
     )
 
-# Launch for HF
+# Launch
 if __name__ == "__main__":
     demo.launch(server_name="0.0.0.0", server_port=7860)