Compress image fix

app.py

@@ -1,17 +1,38 @@
 import gradio as gr
 from src.utils.add_text import add_text_to_image_base64
-from src.utils.change_format import change_format
+from src.utils.compress import compress_image_memory, compress_image_file
 from src.utils.remove_background import remove_background_from_url
 from src.utils.visualize_image import visualize_base64_image
 from src.utils.generate_image import generate_image
 from src.utils.apply_filter import apply_filter_direct
 from src.utils.watermark import add_watermark, remove_watermark
 from src.utils.describe import describe_image
-from src.utils.compress import compress_image
 import base64
 from PIL import Image
 import io
 import requests
+from io import BytesIO
+from typing import Union
+
+def change_format(image: Union[str, BytesIO], target_format: str) -> str:
+    """
+    Change the format of an image from a URL to the specified target format.
+    """
+    
+    if not isinstance(image, BytesIO):
+        response = requests.get(image, timeout=30)
+        response.raise_for_status()
+        img = Image.open(BytesIO(response.content))
+    else: 
+        img = Image.open(image)
+    
+    output = BytesIO()
+    img.save(output, format=target_format)
+    output.seek(0)
+    
+    encoded_image = base64.b64encode(output.getvalue()).decode('utf-8')
+    
+    return encoded_image
 
 def image_to_base64(image):
     if image is None:
@@ -70,7 +91,6 @@ def gradio_generate_image(prompt, width=512, height=512):
         print(f"Error generating image: {e}")
         return None
 
-
 def gradio_apply_filter(image, filter_type, intensity=1.0):
     if image is None:
         print("No image provided")
@@ -120,12 +140,14 @@ def gradio_remove_watermark(image):
         return image
 
 def gradio_compress_image(image, quality=80):
+    """
+    Compress image for Gradio interface - FUNCIÓN CORREGIDA
+    """
     if image is None:
         return None
     try:
-        base64_img = image_to_base64(image)
-        result = compress_image(base64_img, quality)
-        return base64_to_image(result)
+        compressed_image = compress_image_memory(image, quality, "JPEG")
+        return compressed_image
     except Exception as e:
         print(f"Error compressing image: {e}")
         return image
@@ -279,7 +301,7 @@ def create_gradio_interface():
                 with gr.Row():
                     compress_input = gr.Image(label="Upload Image", type="pil")
                     with gr.Column():
-                        quality_slider = gr.Slider(10, 100, 80, label="Quality %")
+                        quality_slider = gr.Slider(0, 100, 80, label="Quality %")
                         compress_output = gr.Image(label="Compressed Image")
                 
                 compress_input.change(gradio_compress_image, [compress_input, quality_slider], compress_output)

src/utils/compress.py

@@ -2,7 +2,7 @@ from PIL import Image
 import os
 from typing import Literal, Optional
 
-def compress_image(
+def compress_image_file(
     input_path: str,
     output_path: str,
     quality: int = 85,
@@ -11,15 +11,7 @@ def compress_image(
     max_height: Optional[int] = None
 ) -> str:
     """
-    Compress an image file.
-    
-    Args:
-        input_path: Path to input image
-        output_path: Path for compressed output
-        quality: Compression quality 1-95 (for JPEG/WEBP)
-        format: Output format
-        max_width: Maximum width (optional)
-        max_height: Maximum height (optional)
+    Compress an image file from disk.
     """
     try:
         if not os.path.splitext(output_path)[1]:
@@ -46,4 +38,22 @@ def compress_image(
         return f"✅ Compressed successfully!\nOriginal: {original_size:.2f}MB → Compressed: {compressed_size:.2f}MB\nReduction: {reduction:.1f}%"
     
     except Exception as e:
-        return f"❌ Error: {str(e)}"
+        return f"❌ Error: {str(e)}"
+
+def compress_image_memory(image: Image.Image, quality: int = 80, format: str = "JPEG") -> Image.Image:
+    """
+    Compress an image in memory and return the compressed image.
+    """
+    if format == "JPEG" and image.mode in ("RGBA", "P"):
+        image = image.convert("RGB")
+    
+    output = BytesIO()
+    save_kwargs = {"format": format, "optimize": True}
+    
+    if format in ["JPEG", "WEBP"]:
+        save_kwargs["quality"] = quality
+    
+    image.save(output, **save_kwargs)
+    output.seek(0)
+    
+    return Image.open(output)