feat: adding converter

pages/1_Cloudinary_AI.py

@@ -5,60 +5,85 @@ import cloudinary.api
 import requests
 import io
 import zipfile
+import logging
+
+# Configuración de la página y del logging
+st.set_page_config(
+    page_title="Cloudinary AI Background Generator",
+    page_icon="🤖",
+    layout="wide"
+)
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 
 
 def init_cloudinary():
-    """Inicializa Cloudinary con credenciales desde secrets"""
+    """
+    Inicializa Cloudinary utilizando las credenciales definidas en st.secrets.
+    Registra en session_state si se inicializó correctamente y realiza una limpieza inicial.
+    """
     if 'cloudinary_initialized' not in st.session_state:
         try:
             cloudinary.config(url=st.secrets['CLOUDINARY_URL'])
             st.session_state.cloudinary_initialized = True
-            cleanup_cloudinary()
+            cleanup_cloudinary()  # Limpieza de recursos al iniciar
+            logging.info("Cloudinary inicializado correctamente.")
         except Exception as e:
             st.error("Error: No se encontraron las credenciales de Cloudinary en secrets.toml")
             st.session_state.cloudinary_initialized = False
+            logging.error(f"Error al inicializar Cloudinary: {e}")
 
 
 def check_file_size(file, max_size_mb=10):
-    file.seek(0, 2)
+    """
+    Verifica que el tamaño del archivo no exceda el límite especificado (en MB).
+    """
+    file.seek(0, io.SEEK_END)
     file_size = file.tell() / (1024 * 1024)
     file.seek(0)
     return file_size <= max_size_mb
 
 
 def cleanup_cloudinary():
-    """Limpia todos los recursos de Cloudinary"""
+    """
+    Limpia todos los recursos almacenados en Cloudinary.
+    """
     if not st.session_state.get('cloudinary_initialized', False):
         return
-
     try:
         result = cloudinary.api.resources()
         if 'resources' in result and result['resources']:
             public_ids = [resource['public_id'] for resource in result['resources']]
             if public_ids:
                 cloudinary.api.delete_resources(public_ids)
+                logging.info("Recursos de Cloudinary limpiados correctamente.")
     except Exception as e:
         st.error(f"Error al limpiar recursos: {e}")
+        logging.error(f"Error al limpiar recursos: {e}")
 
 
 def process_image(image, width, height, dpr):
     """
-    Procesa la imagen usando Cloudinary. Se asegura de reiniciar el puntero del archivo.
-    Retorna una tupla (imagen_procesada_bytes, extension_del_archivo).
+    Procesa la imagen utilizando Cloudinary aplicando una transformación definida.
+
+    Parámetros:
+    - image: Objeto tipo BytesIO con la imagen a procesar.
+    - width, height: Dimensiones deseadas.
+    - dpr: Escalado de resolución.
+
+    Retorna:
+    - Tuple con la imagen procesada en bytes y la extensión del archivo.
     """
     if not st.session_state.get('cloudinary_initialized', False):
         st.error("Cloudinary no está inicializado correctamente")
         return None, None
 
     try:
-        # Reiniciar el puntero para garantizar la lectura completa
         image.seek(0)
         if not check_file_size(image, 10):
             st.error("La imagen excede el límite de 10MB")
             return None, None
 
         image_content = image.read()
-
         response = cloudinary.uploader.upload(
             image_content,
             transformation=[{
@@ -71,52 +96,57 @@ def process_image(image, width, height, dpr):
                 "flags": "preserve_transparency"
             }]
         )
-
         processed_url = response['secure_url']
         processed_image = requests.get(processed_url).content
-        file_format = response.get('format', 'jpg')  # Se obtiene el formato real procesado
+        file_format = response.get('format', 'jpg')
+        logging.info("Imagen procesada correctamente.")
         return processed_image, file_format
     except Exception as e:
         st.error(f"Error procesando imagen: {e}")
+        logging.error(f"Error en process_image: {e}")
         return None, None
 
 
 def main():
+    """
+    Función principal que configura la interfaz de la aplicación y coordina el flujo de procesamiento.
+    """
     init_cloudinary()
 
     st.title("🤖 Cloudinary AI Background Generator")
 
     with st.expander("📌 ¿Cómo usar esta herramienta?", expanded=True):
-        st.markdown("""
-        **Transforma tus imágenes automáticamente con IA:**                    
-
-        Esta herramienta utiliza la IA de Cloudinary para:
-        - 🔄 Redimensionar imágenes manteniendo la relación de aspecto
-        - 🎨 Generar fondos coherentes con la imagen usando IA
-        - 📥 Descargar múltiples imágenes procesadas en un ZIP
-
-        **Formatos soportados:**
-        ✅ PNG, JPG, JPEG, WEBP
-
-        **Pasos para usar:**
-        1. ⚙️ Define las dimensiones deseadas (ancho y alto)
-        2. 📤 Sube tus imágenes (hasta 10MB c/u)
-        3. 🚀 Haz clic en "Procesar Imágenes"
-        4. ⏬ Descarga los resultados finales
-
-        **Características clave:**
-        - Mantiene transparencia en PNGs
-        - Soporte para formatos modernos (WEBP)
-        - Calidad ultra HD (DPR configurable entre 1 y 3)
-        - Procesamiento por lotes
-        - Fondo generado por IA se adapta al contexto
-
-        **Notas importantes:**
-        - Las imágenes subidas se borrarán automáticamente después del procesamiento
-        - Para mejores resultados con IA, usa imágenes con sujetos bien definidos
-        - El tiempo de procesamiento varía según el tamaño y cantidad de imágenes
-        """)
+        st.markdown(
+            """
+            **Transforma tus imágenes automáticamente con IA:**
+            - 🔄 Redimensiona manteniendo la relación de aspecto
+            - 🎨 Genera fondos coherentes usando IA
+            - 📥 Descarga múltiples imágenes en un ZIP
+    
+            **Formatos soportados:**
+            - PNG, JPG, JPEG, WEBP
+    
+            **Pasos para usar:**
+            1. Define las dimensiones deseadas (ancho y alto)
+            2. Sube tus imágenes (hasta 10MB cada una)
+            3. Haz clic en "Procesar Imágenes"
+            4. Descarga los resultados finales
+    
+            **Características clave:**
+            - Preserva transparencia en PNGs
+            - Soporte para formatos modernos (WEBP)
+            - Calidad ultra HD (DPR configurable entre 1 y 3)
+            - Procesamiento por lotes
+            - Fondo generado por IA adaptado al contexto
+    
+            **Notas:**
+            - Las imágenes subidas se borran automáticamente después del procesamiento
+            - Para mejores resultados, usa imágenes con sujetos bien definidos
+            - El tiempo de procesamiento varía según el tamaño y cantidad de imágenes
+            """
+        )
 
+    # Sección de parámetros de configuración
     col1, col2, col3 = st.columns(3)
     with col1:
         width = st.number_input("Ancho (px)", value=1000, min_value=100, max_value=3000)
@@ -125,6 +155,7 @@ def main():
     with col3:
         dpr = st.number_input("DPR", value=3, min_value=1, max_value=3, step=1)
 
+    # Carga de archivos de imagen
     uploaded_files = st.file_uploader(
         "Sube tus imágenes (máx. 10MB por archivo)",
         type=['png', 'jpg', 'jpeg', 'webp'],
@@ -134,13 +165,12 @@ def main():
     if uploaded_files:
         st.header("Imágenes Originales")
         cols = st.columns(3)
-        # Guardar el contenido original para evitar que se consuma el stream
         original_images = []
         for idx, file in enumerate(uploaded_files):
             file_bytes = file.getvalue()
             original_images.append((file.name, file_bytes))
             with cols[idx % 3]:
-                st.image(file_bytes)
+                st.image(file_bytes, caption=file.name, use_column_width=True)
 
         if st.button("Procesar Imágenes"):
             if not st.session_state.get('cloudinary_initialized', False):
@@ -151,7 +181,6 @@ def main():
             progress_bar = st.progress(0)
 
             for idx, (name, img_bytes) in enumerate(original_images):
-                # Crear un nuevo objeto BytesIO para cada imagen
                 img_io = io.BytesIO(img_bytes)
                 with st.spinner(f'Procesando imagen {idx + 1}/{len(original_images)}...'):
                     processed, file_format = process_image(img_io, width, height, dpr)
@@ -164,8 +193,9 @@ def main():
                 cols = st.columns(3)
                 for idx, (img_bytes, file_format) in enumerate(processed_images):
                     with cols[idx % 3]:
-                        st.image(img_bytes)
+                        st.image(img_bytes, caption=f"Formato: {file_format}", use_column_width=True)
 
+                # Empaquetado en ZIP
                 zip_buffer = io.BytesIO()
                 with zipfile.ZipFile(zip_buffer, 'w') as zip_file:
                     for idx, (img_bytes, file_format) in enumerate(processed_images):

pages/2_Cloudinary_Crop.py

@@ -5,47 +5,67 @@ import cloudinary.api
 import requests
 import io
 import zipfile
+import logging
+
+# Configuración inicial de la página y logging
+st.set_page_config(
+    page_title="✂️ Cloudinary Smart Crop",
+    page_icon="✂️",
+    layout="wide"
+)
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 
 
 def init_cloudinary():
-    """Inicializa Cloudinary con credenciales desde secrets"""
+    """
+    Inicializa Cloudinary usando las credenciales definidas en st.secrets.
+    Realiza una limpieza inicial de recursos y registra el estado de inicialización.
+    """
     if 'cloudinary_initialized' not in st.session_state:
         try:
             cloudinary.config(url=st.secrets['CLOUDINARY_URL'])
             st.session_state.cloudinary_initialized = True
-            cleanup_cloudinary()
+            cleanup_cloudinary()  # Limpieza inicial de recursos
+            logging.info("Cloudinary inicializado correctamente.")
         except Exception as e:
             st.error("Error: No se encontraron las credenciales de Cloudinary en secrets.toml")
             st.session_state.cloudinary_initialized = False
+            logging.error(f"Error al inicializar Cloudinary: {e}")
 
 
 def check_file_size(file, max_size_mb=10):
-    file.seek(0, 2)
+    """
+    Verifica que el tamaño del archivo no exceda el límite especificado (en MB).
+    """
+    file.seek(0, 2)  # Mover al final del archivo
     file_size = file.tell() / (1024 * 1024)
-    file.seek(0)
+    file.seek(0)  # Regresar al inicio
     return file_size <= max_size_mb
 
 
 def cleanup_cloudinary():
-    """Limpia todos los recursos de Cloudinary"""
+    """
+    Limpia todos los recursos almacenados en Cloudinary.
+    """
     if not st.session_state.get('cloudinary_initialized', False):
         return
-
     try:
         result = cloudinary.api.resources()
         if 'resources' in result and result['resources']:
             public_ids = [resource['public_id'] for resource in result['resources']]
             if public_ids:
                 cloudinary.api.delete_resources(public_ids)
+                logging.info("Recursos de Cloudinary limpiados.")
     except Exception as e:
         st.error(f"Error al limpiar recursos: {e}")
+        logging.error(f"Error en cleanup_cloudinary: {e}")
 
 
 def process_image(image, width, height, gravity_option, dpr):
     """
     Procesa la imagen usando Cloudinary y retorna la imagen procesada.
-    Se reinicia el puntero del stream y se utiliza el atributo 'name'
-    para determinar si se debe preservar la transparencia en PNG.
+    Reinicia el puntero del stream y utiliza el atributo 'name' para determinar
+    si se debe preservar la transparencia en PNG.
     """
     if not st.session_state.get('cloudinary_initialized', False):
         st.error("Cloudinary no está inicializado correctamente")
@@ -60,31 +80,43 @@ def process_image(image, width, height, gravity_option, dpr):
 
         image_content = image.read()
 
+        # Configurar la transformación para Cloudinary
+        transformation = {
+            "width": width,
+            "height": height,
+            "crop": "fill",
+            "gravity": gravity_option,
+            "quality": 100,
+            "dpr": dpr,
+        }
+        if image_name.lower().endswith('.png'):
+            transformation["flags"] = "preserve_transparency"
+        else:
+            transformation["flags"] = None
+
         response = cloudinary.uploader.upload(
             image_content,
-            transformation=[{
-                "width": width,
-                "height": height,
-                "crop": "fill",
-                "gravity": gravity_option,
-                "quality": 100,
-                "dpr": dpr,
-                "flags": "preserve_transparency" if image_name.lower().endswith('.png') else None
-            }]
+            transformation=[transformation]
         )
 
-        processed_url = response['secure_url']
+        processed_url = response.get('secure_url')
         processed_image = requests.get(processed_url).content
 
         # Limpia el recurso procesado en Cloudinary
-        cloudinary.api.delete_resources([response['public_id']])
+        cloudinary.api.delete_resources([response.get('public_id')])
+        logging.info(f"Imagen {image_name} procesada correctamente.")
         return processed_image
+
     except Exception as e:
         st.error(f"Error procesando imagen: {e}")
+        logging.error(f"Error en process_image para {image_name}: {e}")
         return None
 
 
 def main():
+    """
+    Función principal que ejecuta la aplicación Streamlit.
+    """
     init_cloudinary()
 
     st.title("✂️ Cloudinary Smart Crop")
@@ -109,6 +141,7 @@ def main():
         4. 🚀 Procesa y descarga los resultados
         """)
 
+    # Parámetros de configuración
     col1, col2, col3, col4 = st.columns(4)
     with col1:
         width = st.number_input("Ancho (px)", value=1000, min_value=100, max_value=3000)
@@ -123,6 +156,7 @@ def main():
     with col4:
         dpr = st.number_input("DPR", value=3, min_value=1, max_value=3, step=1)
 
+    # Carga de imágenes
     uploaded_files = st.file_uploader(
         "Sube tus imágenes (máx. 10MB por archivo)",
         type=['png', 'jpg', 'jpeg', 'webp'],
@@ -137,27 +171,30 @@ def main():
             file_bytes = file.getvalue()
             original_images.append((file.name, file_bytes))
             with cols[idx % 3]:
-                st.image(file_bytes, caption=file.name)
+                st.image(file_bytes, caption=file.name, use_column_width=True)
 
         if st.button("✨ Procesar Imágenes"):
             processed_images = []
             progress_bar = st.progress(0)
+            total_images = len(original_images)
 
             for idx, (name, img_bytes) in enumerate(original_images):
                 st.write(f"Procesando: {name}")
                 img_io = io.BytesIO(img_bytes)
-                processed = process_image(img_io, width, height, gravity_option, dpr)
-                if processed:
-                    processed_images.append((name, processed))
-                progress_bar.progress((idx + 1) / len(original_images))
+                with st.spinner(f"Procesando {name}..."):
+                    processed = process_image(img_io, width, height, gravity_option, dpr)
+                    if processed:
+                        processed_images.append((name, processed))
+                progress_bar.progress((idx + 1) / total_images)
 
             if processed_images:
                 st.header("Resultados Finales")
                 cols = st.columns(3)
                 for idx, (name, img_bytes) in enumerate(processed_images):
                     with cols[idx % 3]:
-                        st.image(img_bytes, caption=name)
+                        st.image(img_bytes, caption=name, use_column_width=True)
 
+                # Crear archivo ZIP con las imágenes procesadas
                 zip_buffer = io.BytesIO()
                 with zipfile.ZipFile(zip_buffer, 'w') as zip_file:
                     for name, img_bytes in processed_images:
@@ -167,8 +204,7 @@ def main():
                     label="📥 Descargar Todas",
                     data=zip_buffer.getvalue(),
                     file_name="imagenes_procesadas.zip",
-                    mime="application/zip",
-                    type="primary"
+                    mime="application/zip"
                 )
 
 

pages/3_Image_Compression_Tool.py

@@ -4,57 +4,74 @@ import io
 import zipfile
 from datetime import datetime
 from pathlib import Path
+import logging
+
+# Configuración de la página y del logging
+st.set_page_config(
+    page_title="📁 Image Compression Tool",
+    page_icon="📁",
+    layout="wide"
+)
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 
 
 def optimize_image(image_file):
-    """Optimiza la imagen automáticamente manteniendo la máxima calidad visual"""
+    """
+    Optimiza la imagen automáticamente manteniendo la máxima calidad visual.
+
+    Parámetros:
+    - image_file: Archivo de imagen (stream) subido por el usuario.
+
+    Retorna:
+    - Tuple con los datos de la imagen optimizada (bytes) y el formato usado.
+    - Si no se logra una reducción de tamaño, retorna (None, None).
+    """
     try:
         img = Image.open(image_file)
         output_buffer = io.BytesIO()
 
-        # Configuración simple por formato
+        # Configuración de parámetros según el formato y modo de la imagen
         if img.format == 'PNG':
-            # Para PNG, mantener transparencia si existe
             if img.mode in ('RGBA', 'LA'):
                 img_to_save = img
-                save_params = {
-                    'format': 'PNG',
-                    'optimize': True
-                }
+                save_params = {'format': 'PNG', 'optimize': True}
             else:
                 img_to_save = img.convert('RGB')
-                save_params = {
-                    'format': 'JPEG',
-                    'quality': 85,
-                    'optimize': True
-                }
+                save_params = {'format': 'JPEG', 'quality': 85, 'optimize': True}
         else:
-            # Para otros formatos, convertir a JPEG
             img_to_save = img.convert('RGB')
-            save_params = {
-                'format': 'JPEG',
-                'quality': 85,
-                'optimize': True
-            }
+            save_params = {'format': 'JPEG', 'quality': 85, 'optimize': True}
 
-        # Guardar imagen optimizada
+        # Guardar la imagen optimizada en un buffer
         img_to_save.save(output_buffer, **save_params)
         output_buffer.seek(0)
 
-        # Validar reducción de tamaño
         optimized_size = len(output_buffer.getvalue())
+        # Se valida que la imagen optimizada sea menor que la original
         if optimized_size >= image_file.size:
+            logging.info("No se logró reducir el tamaño de la imagen.")
             return None, None
 
+        logging.info("Imagen optimizada exitosamente.")
         return output_buffer.getvalue(), save_params['format']
 
     except Exception as e:
-        st.error(f"Error optimizando imagen: {str(e)}")
+        st.error(f"Error optimizando imagen: {e}")
+        logging.error(f"Error en optimize_image: {e}")
         return None, None
 
 
 def process_filename(original_name, optimized_format):
-    """Genera nombre de archivo optimizado usando pathlib y el formato optimizado"""
+    """
+    Genera un nuevo nombre de archivo para la imagen optimizada.
+
+    Parámetros:
+    - original_name: Nombre original del archivo.
+    - optimized_format: Formato de la imagen optimizada.
+
+    Retorna:
+    - String con el nuevo nombre (por ejemplo, 'foto_optimizado.jpg').
+    """
     path = Path(original_name)
     new_suffix = f".{optimized_format.lower()}" if optimized_format else '.jpg'
     return f"{path.stem}_optimizado{new_suffix}"
@@ -64,16 +81,18 @@ def main():
     st.title("📁 Image Compression Tool")
 
     with st.expander("📌 Instrucciones de uso", expanded=True):
-        st.markdown("""
-        **Optimización automática de imágenes con máxima calidad visual**
-
-        **Características:**
-        - 🔍 Compresión inteligente automática
-        - 🖼️ Mantiene transparencia en PNG
-        - 📉 Reducción de tamaño garantizada
-        - 🚀 Procesamiento por lotes
-        - 📥 Descarga múltiple en ZIP
-        """)
+        st.markdown(
+            """
+            **Optimización automática de imágenes con máxima calidad visual**
+    
+            **Características:**
+            - 🔍 Compresión inteligente automática
+            - 🖼️ Mantiene transparencia en PNG
+            - 📉 Reducción de tamaño garantizada
+            - 🚀 Procesamiento por lotes
+            - 📥 Descarga múltiple en ZIP
+            """
+        )
 
     uploaded_files = st.file_uploader(
         "Sube tus imágenes (máx. 50MB por archivo)",
@@ -88,11 +107,13 @@ def main():
         total_files = len(uploaded_files)
 
         st.info("Optimizando imágenes...")
+        logging.info(f"Se subieron {total_files} archivos para optimización.")
 
         for idx, file in enumerate(uploaded_files):
             try:
                 if file.size > 50 * 1024 * 1024:
-                    st.error(f"Archivo {file.name} excede 50MB")
+                    st.error(f"El archivo {file.name} excede 50MB")
+                    logging.warning(f"El archivo {file.name} excede el tamaño máximo permitido.")
                     continue
 
                 original_size = file.size
@@ -107,18 +128,20 @@ def main():
                     processed_images.append((new_name, optimized_data, original_size, new_size))
 
                     st.write(f"✅ {file.name} optimizado ({reduction / 1024:.1f} KB ahorrados)")
+                    logging.info(f"{file.name} optimizado. Ahorro: {reduction / 1024:.1f} KB.")
                 else:
                     st.write(f"⚠️ {file.name} no se optimizó porque no se logró reducir el tamaño.")
+                    logging.info(f"{file.name} no se optimizó, no hubo reducción de tamaño.")
 
                 progress_bar.progress((idx + 1) / total_files)
 
             except Exception as e:
-                st.error(f"Error procesando {file.name}: {str(e)}")
+                st.error(f"Error procesando {file.name}: {e}")
+                logging.error(f"Error procesando {file.name}: {e}")
 
         st.success(f"¡Optimización completada! (Ahorro total: {total_reduction / 1024:.1f} KB)")
 
         if processed_images:
-            # Mostrar resultados
             st.subheader("Resultados de Optimización")
             cols = st.columns(3)
             with cols[0]:
@@ -129,13 +152,12 @@ def main():
                 avg_reduction = (total_reduction / len(processed_images)) / 1024
                 st.metric("Reducción promedio", f"{avg_reduction:.1f} KB")
 
-            # Generar ZIP
+            # Crear archivo ZIP con las imágenes optimizadas
             zip_buffer = io.BytesIO()
             with zipfile.ZipFile(zip_buffer, 'w', zipfile.ZIP_DEFLATED) as zip_file:
                 for name, data, _, _ in processed_images:
                     zip_file.writestr(name, data)
 
-            # Botón de descarga
             st.download_button(
                 label="📥 Descargar Todas las Imágenes",
                 data=zip_buffer.getvalue(),

pages/4_Image_Converter.py

@@ -0,0 +1,119 @@
+import streamlit as st
+from PIL import Image, UnidentifiedImageError
+import io
+import zipfile
+import logging
+
+# Configuración inicial de la página y logging
+st.set_page_config(
+    page_title="Image Converter",
+    page_icon="🖼️",
+    layout="wide"
+)
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
+
+
+def convert_image(image_file, output_format):
+    """
+    Verifica la integridad del archivo y lo convierte al formato de salida deseado.
+
+    Parámetros:
+    - image_file: objeto BytesIO del archivo de imagen.
+    - output_format: cadena con el formato de salida deseado ('png' o 'jpg').
+
+    Retorna:
+    - Los bytes de la imagen convertida o None si ocurre algún error.
+    """
+    image_name = getattr(image_file, 'name', 'Imagen sin nombre')
+    try:
+        # Intentamos abrir y verificar la integridad de la imagen
+        image_file.seek(0)
+        image = Image.open(image_file)
+        image.verify()  # Esto lanza una excepción si el archivo está dañado
+        logging.info(f"{image_name} verificado correctamente.")
+
+        # Reiniciamos el puntero y volvemos a abrir la imagen para poder manipularla
+        image_file.seek(0)
+        image = Image.open(image_file)
+    except (UnidentifiedImageError, Exception) as e:
+        st.error(f"El archivo {image_name} está dañado o es inválido: {e}")
+        logging.error(f"Error al verificar {image_name}: {e}")
+        return None
+
+    # Para JPG es necesario que la imagen esté en modo RGB
+    if output_format.lower() == "jpg" and image.mode != "RGB":
+        image = image.convert("RGB")
+
+    output_io = io.BytesIO()
+    try:
+        image.save(output_io, format=output_format.upper())
+        logging.info(f"{image_name} convertido a {output_format}.")
+        return output_io.getvalue()
+    except Exception as e:
+        st.error(f"Error al convertir {image_name}: {e}")
+        logging.error(f"Error al guardar {image_name}: {e}")
+        return None
+
+
+def main():
+    st.title("Conversor de Formatos de Imagen")
+    st.markdown("Convierte tus imágenes al formato deseado y verifica la integridad de cada archivo.")
+
+    # Selección del formato de salida
+    output_format = st.selectbox(
+        "Formato de salida",
+        ["png", "jpg"],
+        help="Selecciona el formato al que deseas convertir la imagen"
+    )
+
+    # Carga de imágenes
+    uploaded_files = st.file_uploader(
+        "Sube tus imágenes (Formatos soportados: PNG, JPG, JPEG, WEBP)",
+        type=['png', 'jpg', 'jpeg', 'webp'],
+        accept_multiple_files=True
+    )
+
+    if uploaded_files:
+        st.header("Vista Previa Original")
+        cols = st.columns(3)
+        original_images = []
+        for idx, file in enumerate(uploaded_files):
+            file_bytes = file.getvalue()
+            original_images.append((file.name, file_bytes))
+            with cols[idx % 3]:
+                st.image(file_bytes, caption=file.name, use_column_width=True)
+
+        if st.button("✨ Convertir Imágenes"):
+            converted_images = []
+            for name, file_bytes in original_images:
+                st.write(f"Procesando: {name}")
+                img_io = io.BytesIO(file_bytes)
+                output_bytes = convert_image(img_io, output_format)
+                if output_bytes:
+                    converted_images.append((name, output_bytes))
+
+            if converted_images:
+                st.header("Imágenes Convertidas")
+                cols = st.columns(3)
+                for idx, (name, img_bytes) in enumerate(converted_images):
+                    with cols[idx % 3]:
+                        st.image(img_bytes, caption=f"{name} convertido a {output_format}", use_column_width=True)
+
+                # Empaquetar las imágenes convertidas en un ZIP
+                zip_buffer = io.BytesIO()
+                with zipfile.ZipFile(zip_buffer, 'w') as zip_file:
+                    for name, img_bytes in converted_images:
+                        # Se ajusta el nombre del archivo con la extensión deseada
+                        base_name = name.rsplit('.', 1)[0]
+                        zip_file.writestr(f"{base_name}.{output_format}", img_bytes)
+
+                st.download_button(
+                    label="📥 Descargar todas las imágenes convertidas",
+                    data=zip_buffer.getvalue(),
+                    file_name="imagenes_convertidas.zip",
+                    mime="application/zip"
+                )
+
+
+if __name__ == "__main__":
+    main()