Update app.py

app.py

@@ -4,74 +4,71 @@ import os
 import tempfile
 
 def optimize_image(image):
-    # Leer la imagen original
     img = Image.open(image)
     
-    # Calcular el tamaño del archivo original
     original_size = os.path.getsize(image.name) / 1024  # tamaño en KB
     
-    # Ruta temporal para guardar las imágenes optimizadas
     with tempfile.TemporaryDirectory() as tmpdirname:
-        # 1. Compresión sin pérdida
         lossless_output_path = os.path.join(tmpdirname, "lossless.png")
         img.save(lossless_output_path, format="PNG", optimize=True)
-        lossless_size = os.path.getsize(lossless_output_path) / 1024  # tamaño en KB
+        lossless_size = os.path.getsize(lossless_output_path) / 1024
         lossless_img = Image.open(lossless_output_path)
         lossless_diff = original_size - lossless_size
         
-        # 2. Compresión con pérdida (reducción de calidad)
         lossy_output_path = os.path.join(tmpdirname, "lossy.jpg")
         img.save(lossy_output_path, format="JPEG", quality=50, optimize=True)
-        lossy_size = os.path.getsize(lossy_output_path) / 1024  # tamaño en KB
+        lossy_size = os.path.getsize(lossy_output_path) / 1024
         lossy_img = Image.open(lossy_output_path)
         lossy_diff = original_size - lossy_size
         
-        # 3. Reducción de resolución
         reduced_output_path = os.path.join(tmpdirname, "reduced_resolution.jpg")
         reduced_img = img.resize((img.width // 2, img.height // 2), Image.LANCZOS)
         reduced_img.save(reduced_output_path, format="JPEG", quality=85, optimize=True)
-        reduced_size = os.path.getsize(reduced_output_path) / 1024  # tamaño en KB
+        reduced_size = os.path.getsize(reduced_output_path) / 1024
         reduced_img = Image.open(reduced_output_path)
         reduced_diff = original_size - reduced_size
 
-        # 4. Compresión con WebP (con pérdida)
         webp_lossy_output_path = os.path.join(tmpdirname, "lossy.webp")
         img.save(webp_lossy_output_path, format="WEBP", quality=50, optimize=True)
-        webp_lossy_size = os.path.getsize(webp_lossy_output_path) / 1024  # tamaño en KB
+        webp_lossy_size = os.path.getsize(webp_lossy_output_path) / 1024
         webp_lossy_img = Image.open(webp_lossy_output_path)
         webp_lossy_diff = original_size - webp_lossy_size
         
-        # Retornar imágenes optimizadas y sus tamaños con la diferencia
-        return (lossless_img, f"Sin pérdida: {lossless_size:.2f} KB (diferencia: {-lossless_diff:.2f} KB)",
-                lossy_img, f"Con pérdida: {lossy_size:.2f} KB (diferencia: {-lossy_diff:.2f} KB)",
-                reduced_img, f"Reducción de resolución: {reduced_size:.2f} KB (diferencia: {-reduced_diff:.2f} KB)",
-                webp_lossy_img, f"WebP con pérdida: {webp_lossy_size:.2f} KB (diferencia: {-webp_lossy_diff:.2f} KB)")
+        return [
+            lossless_img, f"Sin pérdida: {lossless_size:.2f} KB (diferencia: {-lossless_diff:.2f} KB)",
+            lossy_img, f"Con pérdida: {lossy_size:.2f} KB (diferencia: {-lossy_diff:.2f} KB)",
+            reduced_img, f"Reducción de resolución: {reduced_size:.2f} KB (diferencia: {-reduced_diff:.2f} KB)",
+            webp_lossy_img, f"WebP con pérdida: {webp_lossy_size:.2f} KB (diferencia: {-webp_lossy_diff:.2f} KB)"
+        ]
 
-# Interfaz de Gradio
 with gr.Blocks() as demo:
     gr.Markdown("### Optimización de imágenes para la web")
 
     image_input = gr.File(label="Sube tu imagen", file_types=['image'])
     optimize_button = gr.Button("Optimizar")
 
-    # Mostrar las imágenes optimizadas y sus tamaños
-    optimized_output1 = gr.Image(label="Optimización sin pérdida")
-    optimized_size1 = gr.Text(label="Tamaño del archivo sin pérdida")
-
-    optimized_output2 = gr.Image(label="Optimización con pérdida")
-    optimized_size2 = gr.Text(label="Tamaño del archivo con pérdida")
+    with gr.Row():
+        optimized_output1 = gr.Image(label="Optimización sin pérdida")
+        optimized_size1 = gr.Text()
+        
+        optimized_output2 = gr.Image(label="Optimización con pérdida")
+        optimized_size2 = gr.Text()
 
-    optimized_output3 = gr.Image(label="Reducción de resolución")
-    optimized_size3 = gr.Text(label="Tamaño del archivo con reducción de resolución")
+        optimized_output3 = gr.Image(label="Reducción de resolución")
+        optimized_size3 = gr.Text()
 
-    optimized_output4 = gr.Image(label="Optimización WebP con pérdida")
-    optimized_size4 = gr.Text(label="Tamaño del archivo WebP con pérdida")
+        optimized_output4 = gr.Image(label="Optimización WebP con pérdida")
+        optimized_size4 = gr.Text()
 
-    optimize_button.click(fn=optimize_image, inputs=image_input, outputs=[
-        optimized_output1, optimized_size1, 
-        optimized_output2, optimized_size2, 
-        optimized_output3, optimized_size3,
-        optimized_output4, optimized_size4
-    ])
+    optimize_button.click(
+        fn=optimize_image,
+        inputs=image_input,
+        outputs=[
+            optimized_output1, optimized_size1,
+            optimized_output2, optimized_size2,
+            optimized_output3, optimized_size3,
+            optimized_output4, optimized_size4
+        ]
+    )
 
 demo.launch()