Update app.py

app.py

@@ -4,6 +4,7 @@ import os
 import tempfile
 import pyheif
 import ntpath
+import shutil
 
 def open_heic_image(image_path):
     heif_file = pyheif.read(image_path)
@@ -17,71 +18,74 @@ def open_heic_image(image_path):
     )
     return img
 
-def optimize_image(image, png_optimize, jpeg_quality, jpeg_resolution, webp_quality):
-    # Obtener el nombre del archivo original sin la extensión
-    original_filename = ntpath.basename(image.name)
+def optimize_single_image(image_path, png_optimize, jpeg_quality, jpeg_resolution, webp_quality):
+    original_filename = ntpath.basename(image_path)
     base_name, ext = os.path.splitext(original_filename)
     
-    # Manejar archivos HEIC
-    if image.name.lower().endswith(".heic"):
-        img = open_heic_image(image.name)
+    if image_path.lower().endswith(".heic"):
+        img = open_heic_image(image_path)
     else:
-        img = Image.open(image)
+        img = Image.open(image_path)
 
-    # Convertir la imagen a RGB si está en RGBA o en un modo no soportado por JPEG
     if img.mode not in ['RGB', 'L']:
         img = img.convert('RGB')
     
-    original_size = os.path.getsize(image.name) / 1024  # tamaño en KB
-    output_dir = "/tmp/optimized_images"
-    os.makedirs(output_dir, exist_ok=True)
+    original_size = os.path.getsize(image_path) / 1024  # tamaño en KB
+    output_dir = tempfile.mkdtemp()  # Crear un directorio temporal para las imágenes optimizadas
     
-    # Lista para almacenar los resultados
-    results = []
+    optimized_images = []
 
-    # Optimización para PNG
     if png_optimize:
         lossless_output_path = os.path.join(output_dir, f"{base_name}-lossless.png")
         img.save(lossless_output_path, format="PNG", optimize=True)
-        lossless_size = os.path.getsize(lossless_output_path) / 1024
-        percent_reduction = 100 * (original_size - lossless_size) / original_size
-        results.append((Image.open(lossless_output_path), f"PNG: {lossless_size:.2f} KB (diferencia: {-percent_reduction:.2f} KB)", lossless_output_path))
+        optimized_images.append(lossless_output_path)
 
-    # Optimización para JPEG
     lossy_output_path = os.path.join(output_dir, f"{base_name}-lossy.jpg")
     img.save(lossy_output_path, format="JPEG", quality=jpeg_quality, optimize=True)
-    lossy_size = os.path.getsize(lossy_output_path) / 1024
-    percent_reduction = 100 * (original_size - lossy_size) / original_size
-    results.append((Image.open(lossy_output_path), f"JPEG: {lossy_size:.2f} KB (diferencia: {-percent_reduction:.2f} KB)", lossy_output_path))
+    optimized_images.append(lossy_output_path)
 
-    # Reducción de resolución (JPEG)
     reduced_output_path = os.path.join(output_dir, f"{base_name}-reduced_resolution.jpg")
     new_resolution = (img.width * jpeg_resolution // 100, img.height * jpeg_resolution // 100)
     reduced_img = img.resize(new_resolution, Image.LANCZOS)
     reduced_img.save(reduced_output_path, format="JPEG", quality=jpeg_quality, optimize=True)
-    reduced_size = os.path.getsize(reduced_output_path) / 1024
-    percent_reduction = 100 * (original_size - reduced_size) / original_size
-    results.append((Image.open(reduced_output_path), f"JPEG (resolución reducida): {reduced_size:.2f} KB (diferencia: {-percent_reduction:.2f} KB)", reduced_output_path))
+    optimized_images.append(reduced_output_path)
 
-    # Optimización para WebP
     webp_lossy_output_path = os.path.join(output_dir, f"{base_name}-lossy.webp")
     img.save(webp_lossy_output_path, format="WEBP", quality=webp_quality, optimize=True)
-    webp_lossy_size = os.path.getsize(webp_lossy_output_path) / 1024
-    percent_reduction = 100 * (original_size - webp_lossy_size) / original_size
-    results.append((Image.open(webp_lossy_output_path), f"WebP: {webp_lossy_size:.2f} KB (diferencia: {-percent_reduction:.2f} KB)", webp_lossy_output_path))
+    optimized_images.append(webp_lossy_output_path)
 
-    # Asegurarse de que todos los resultados están presentes (4 entradas)
-    while len(results) < 4:
-        results.append((None, "", None))
-    
-    # Dividir los resultados en imágenes, textos y rutas para descarga
-    outputs = []
-    for result in results:
-        outputs.extend(result)
+    return optimized_images
+
+def optimize_zip_images(zip_file, png_optimize, jpeg_quality, jpeg_resolution, webp_quality):
+    with tempfile.TemporaryDirectory() as tmp_dir:
+        shutil.unpack_archive(zip_file.name, tmp_dir)
+        output_dir = tempfile.mkdtemp()
+
+        optimized_files = []
 
-    return outputs
+        for root, _, files in os.walk(tmp_dir):
+            for file in files:
+                file_path = os.path.join(root, file)
+                optimized_images = optimize_single_image(file_path, png_optimize, jpeg_quality, jpeg_resolution, webp_quality)
+                for optimized_image in optimized_images:
+                    output_path = os.path.join(output_dir, ntpath.basename(optimized_image))
+                    shutil.move(optimized_image, output_path)
+                    optimized_files.append(output_path)
+
+        zip_output_path = os.path.join(output_dir, "optimized_images.zip")
+        shutil.make_archive(zip_output_path.replace(".zip", ""), 'zip', output_dir)
+
+        return zip_output_path, optimized_files
 
 with gr.Blocks() as demo:
+    gr.Markdown("""
+    # Optimización de Imágenes para la Web
+    Esta aplicación te permite optimizar imágenes individuales o múltiples imágenes a través de un archivo ZIP.
+    
+    - **Pestaña "Optimización Tradicional"**: Sube una imagen individual para optimización y descarga.
+    - **Pestaña "Optimización por Lote"**: Elige los parámetros de optimización, sube un archivo ZIP con múltiples imágenes y descarga todas las imágenes optimizadas.
+    """)
+
     with gr.Tab("Optimización Tradicional"):
         image_input = gr.File(label="Sube tu imagen", file_types=['image', '.heic'])
         optimize_button = gr.Button("Optimizar")
@@ -95,25 +99,24 @@ with gr.Blocks() as demo:
 
             with gr.Column():
                 optimized_output2 = gr.Image(label="Optimización con pérdida (JPEG)")
-                jpeg_quality = gr.Slider(label="Calidad JPEG", minimum=10, maximum=100, value=75, step=1)
+                jpeg_quality = gr.Slider(label="Calidad JPEG", minimum=10, maximum=100, value=50, step=1)
                 download_button2 = gr.File(label="Descargar", visible=True)
                 optimized_size2 = gr.Text(value="", interactive=False, show_label=False)
                 
             with gr.Column():
                 optimized_output3 = gr.Image(label="Reducción de resolución (JPEG)")
-                jpeg_resolution = gr.Slider(label="Resolución JPEG (%)", minimum=10, maximum=100, value=75, step=1)
+                jpeg_resolution = gr.Slider(label="Resolución JPEG (%)", minimum=10, maximum=100, value=50, step=1)
                 download_button3 = gr.File(label="Descargar", visible=True)
                 optimized_size3 = gr.Text(value="", interactive=False, show_label=False)
 
             with gr.Column():
                 optimized_output4 = gr.Image(label="Optimización WebP con pérdida")
-                webp_quality = gr.Slider(label="Calidad WebP", minimum=10, maximum=100, value=75, step=1)
+                webp_quality = gr.Slider(label="Calidad WebP", minimum=10, maximum=100, value=50, step=1)
                 download_button4 = gr.File(label="Descargar", visible=True)
                 optimized_size4 = gr.Text(value="", interactive=False, show_label=False)
 
-        # Conectar cada control a la función de optimización
         optimize_button.click(
-            fn=optimize_image,
+            fn=optimize_single_image,
             inputs=[image_input, png_optimize, jpeg_quality, jpeg_resolution, webp_quality],
             outputs=[
                 optimized_output1, optimized_size1, download_button1,
@@ -123,4 +126,23 @@ with gr.Blocks() as demo:
             ]
         )
 
+    with gr.Tab("Optimización por Lote"):
+        with gr.Row():
+            png_optimize_batch = gr.Checkbox(label="Optimizar PNG", value=True)
+            jpeg_quality_batch = gr.Slider(label="Calidad JPEG", minimum=10, maximum=100, value=50, step=1)
+            jpeg_resolution_batch = gr.Slider(label="Resolución JPEG (%)", minimum=10, maximum=100, value=50, step=1)
+            webp_quality_batch = gr.Slider(label="Calidad WebP", minimum=10, maximum=100, value=50, step=1)
+        
+        zip_input = gr.File(label="Sube tu archivo ZIP con imágenes", file_types=['.zip'])
+        optimize_batch_button = gr.Button("Optimizar Imágenes en ZIP")
+        
+        batch_output_zip = gr.File(label="Descargar ZIP de imágenes optimizadas", visible=True)
+        batch_output_files = gr.File(label="Descargar imágenes individuales", visible=True, multiple=True)
+
+        optimize_batch_button.click(
+            fn=optimize_zip_images,
+            inputs=[zip_input, png_optimize_batch, jpeg_quality_batch, jpeg_resolution_batch, webp_quality_batch],
+            outputs=[batch_output_zip, batch_output_files]
+        )
+
 demo.launch()