Update app.py

app.py

@@ -9,18 +9,21 @@ def optimize_image(image):
     original_size = os.path.getsize(image.name) / 1024  # tamaño en KB
     
     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
         lossless_img = Image.open(lossless_output_path)
         lossless_diff = original_size - lossless_size
         
+        # 2. Compresión con pérdida (JPEG)
         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
         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)
@@ -28,19 +31,25 @@ def optimize_image(image):
         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
         webp_lossy_img = Image.open(webp_lossy_output_path)
         webp_lossy_diff = original_size - webp_lossy_size
         
+        # Retornar las imágenes optimizadas, tamaños y rutas para descarga
         return [
-            lossless_img, f"Sin pérdida: {lossless_size:.2f} KB ({-lossless_diff:.2f} KB)", lossless_output_path,
-            lossy_img, f"Con pérdida: {lossy_size:.2f} KB ({-lossy_diff:.2f} KB)", lossy_output_path,
-            reduced_img, f"Reducción de resolución: {reduced_size:.2f} KB ({-reduced_diff:.2f} KB)", reduced_output_path,
-            webp_lossy_img, f"WebP con pérdida: {webp_lossy_size:.2f} KB ({-webp_lossy_diff:.2f} KB)", webp_lossy_output_path
+            lossless_img, f"Sin pérdida: {lossless_size:.2f} KB (diferencia: {-lossless_diff:.2f} KB)", lossless_output_path,
+            lossy_img, f"Con pérdida: {lossy_size:.2f} KB (diferencia: {-lossy_diff:.2f} KB)", lossy_output_path,
+            reduced_img, f"Reducción de resolución: {reduced_size:.2f} KB (diferencia: {-reduced_diff:.2f} KB)", reduced_output_path,
+            webp_lossy_img, f"WebP con pérdida: {webp_lossy_size:.2f} KB (diferencia: {-webp_lossy_diff:.2f} KB)", webp_lossy_output_path
         ]
 
+def download_image(file_path):
+    # Función para servir el archivo para descarga
+    return gr.File.update(value=file_path, visible=True)
+
 with gr.Blocks() as demo:
     gr.Markdown("### Optimización de imágenes para la web")
 
@@ -50,24 +59,29 @@ with gr.Blocks() as demo:
     with gr.Row():
         with gr.Column():
             optimized_output1 = gr.Image(label="Optimización sin pérdida")
-            optimized_size1 = gr.Text(visible=False)
+            optimized_size1 = gr.Text()
             download_button1 = gr.Button("Descargar")
-        
+            download_file1 = gr.File()
+
         with gr.Column():
             optimized_output2 = gr.Image(label="Optimización con pérdida")
-            optimized_size2 = gr.Text(visible=False)
+            optimized_size2 = gr.Text()
             download_button2 = gr.Button("Descargar")
+            download_file2 = gr.File()
 
         with gr.Column():
             optimized_output3 = gr.Image(label="Reducción de resolución")
-            optimized_size3 = gr.Text(visible=False)
+            optimized_size3 = gr.Text()
             download_button3 = gr.Button("Descargar")
+            download_file3 = gr.File()
 
         with gr.Column():
             optimized_output4 = gr.Image(label="Optimización WebP con pérdida")
-            optimized_size4 = gr.Text(visible=False)
+            optimized_size4 = gr.Text()
             download_button4 = gr.Button("Descargar")
+            download_file4 = gr.File()
 
+    # Conectar la optimización con los outputs
     optimize_button.click(
         fn=optimize_image,
         inputs=image_input,
@@ -79,9 +93,10 @@ with gr.Blocks() as demo:
         ]
     )
 
-    download_button1.click(lambda x: x, inputs=optimized_size1, outputs=download_button1)
-    download_button2.click(lambda x: x, inputs=optimized_size2, outputs=download_button2)
-    download_button3.click(lambda x: x, inputs=optimized_size3, outputs=download_button3)
-    download_button4.click(lambda x: x, inputs=optimized_size4, outputs=download_button4)
+    # Conectar los botones de descarga
+    download_button1.click(download_image, inputs=download_button1, outputs=download_file1)
+    download_button2.click(download_image, inputs=download_button2, outputs=download_file2)
+    download_button3.click(download_image, inputs=download_button3, outputs=download_file3)
+    download_button4.click(download_image, inputs=download_button4, outputs=download_file4)
 
 demo.launch()