fix: an issue with the format

pages/1_Cloudinary_AI.py

@@ -42,14 +42,20 @@ def cleanup_cloudinary():
 
 
 def process_image(image, width, height):
+    """
+    Procesa la imagen usando Cloudinary. Se asegura de reiniciar el puntero del archivo.
+    Retorna una tupla (imagen_procesada_bytes, extension_del_archivo).
+    """
     if not st.session_state.get('cloudinary_initialized', False):
         st.error("Cloudinary no está inicializado correctamente")
-        return None
+        return None, None
 
     try:
+        # Reiniciar el puntero para garantizar la lectura completa
+        image.seek(0)
         if not check_file_size(image, 10):
-            st.error(f"La imagen {image.name} excede el límite de 10MB")
-            return None
+            st.error(f"La imagen excede el límite de 10MB")
+            return None, None
 
         image_content = image.read()
 
@@ -68,10 +74,11 @@ def process_image(image, width, height):
 
         processed_url = response['secure_url']
         processed_image = requests.get(processed_url).content
-        return processed_image
+        file_format = response.get('format', 'jpg')  # Se obtiene el formato real procesado
+        return processed_image, file_format
     except Exception as e:
         st.error(f"Error procesando imagen: {e}")
-        return None
+        return None, None
 
 
 def main():
@@ -125,9 +132,13 @@ 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)
+                st.image(file_bytes)
 
         if st.button("Procesar Imágenes"):
             if not st.session_state.get('cloudinary_initialized', False):
@@ -137,24 +148,26 @@ def main():
             processed_images = []
             progress_bar = st.progress(0)
 
-            for idx, file in enumerate(uploaded_files):
-                with st.spinner(f'Procesando imagen {idx + 1}/{len(uploaded_files)}...'):
-                    processed = process_image(file, width, height)
+            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)
                     if processed:
-                        processed_images.append(processed)
-                    progress_bar.progress((idx + 1) / len(uploaded_files))
+                        processed_images.append((processed, file_format))
+                    progress_bar.progress((idx + 1) / len(original_images))
 
             if processed_images:
                 st.header("Imágenes Procesadas")
                 cols = st.columns(3)
-                for idx, img_bytes in enumerate(processed_images):
+                for idx, (img_bytes, file_format) in enumerate(processed_images):
                     with cols[idx % 3]:
                         st.image(img_bytes)
 
                 zip_buffer = io.BytesIO()
                 with zipfile.ZipFile(zip_buffer, 'w') as zip_file:
-                    for idx, img_bytes in enumerate(processed_images):
-                        zip_file.writestr(f'imagen_procesada_{idx}.jpg', img_bytes)
+                    for idx, (img_bytes, file_format) in enumerate(processed_images):
+                        zip_file.writestr(f'imagen_procesada_{idx}.{file_format}', img_bytes)
 
                 st.download_button(
                     label="Descargar todas las imágenes",
@@ -165,4 +178,4 @@ def main():
 
 
 if __name__ == "__main__":
-    main()
+    main()

pages/2_Cloudinary_Crop.py

@@ -42,13 +42,21 @@ def cleanup_cloudinary():
 
 
 def process_image(image, width, height, gravity_option):
+    """
+    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.
+    """
     if not st.session_state.get('cloudinary_initialized', False):
         st.error("Cloudinary no está inicializado correctamente")
         return None
 
     try:
+        # Reinicia el puntero para leer la imagen completa
+        image.seek(0)
+        image_name = getattr(image, 'name', '')
         if not check_file_size(image, 10):
-            st.error(f"La imagen {image.name} excede el límite de 10MB")
+            st.error(f"{image_name} excede el límite de 10MB")
             return None
 
         image_content = image.read()
@@ -62,13 +70,14 @@ def process_image(image, width, height, gravity_option):
                 "gravity": gravity_option,
                 "quality": 100,
                 "dpr": 3,
-                "flags": "preserve_transparency" if image.name.lower().endswith('.png') else None
+                "flags": "preserve_transparency" if image_name.lower().endswith('.png') else None
             }]
         )
 
         processed_url = response['secure_url']
         processed_image = requests.get(processed_url).content
 
+        # Limpia el recurso procesado en Cloudinary
         cloudinary.api.delete_resources([response['public_id']])
         return processed_image
     except Exception as e:
@@ -122,26 +131,26 @@ def main():
     if uploaded_files:
         st.header("Vista Previa Original")
         cols = st.columns(3)
+        # Almacena el contenido original de cada imagen en memoria
+        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, caption=file.name)
+                st.image(file_bytes, caption=file.name)
 
         if st.button("✨ Procesar Imágenes"):
             processed_images = []
             progress_bar = st.progress(0)
 
-            with st.status("Procesando imágenes...", expanded=True) as status:
-                for idx, file in enumerate(uploaded_files):
-                    try:
-                        st.write(f"Procesando: {file.name}")
-                        processed = process_image(file, width, height, gravity_option)
-                        if processed:
-                            processed_images.append((file.name, processed))
-                            progress_bar.progress((idx + 1) / len(uploaded_files))
-                    except Exception as e:
-                        st.error(f"Error con {file.name}: {str(e)}")
-
-                status.update(label="Proceso completado!", state="complete")
+            # Procesa cada imagen utilizando un nuevo objeto BytesIO
+            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)
+                if processed:
+                    processed_images.append((name, processed))
+                progress_bar.progress((idx + 1) / len(original_images))
 
             if processed_images:
                 st.header("Resultados Finales")
@@ -153,7 +162,7 @@ def main():
                 zip_buffer = io.BytesIO()
                 with zipfile.ZipFile(zip_buffer, 'w') as zip_file:
                     for name, img_bytes in processed_images:
-                        ext = name.split('.')[-1].lower()
+                        # Se utiliza el nombre original para mantener la extensión
                         zip_file.writestr(f"procesada_{name}", img_bytes)
 
                 st.download_button(
@@ -166,4 +175,4 @@ def main():
 
 
 if __name__ == "__main__":
-    main()
+    main()

pages/3_Image_Compression_Tool.py

@@ -53,12 +53,10 @@ def optimize_image(image_file):
         return None, None
 
 
-def process_filename(original_name):
-    """Genera nombre de archivo optimizado usando pathlib"""
+def process_filename(original_name, optimized_format):
+    """Genera nombre de archivo optimizado usando pathlib y el formato optimizado"""
     path = Path(original_name)
-    new_suffix = '.jpg'  # Por defecto usamos .jpg
-    if path.suffix.lower() in ['.png', '.PNG'] and Image.open(original_name).mode in ('RGBA', 'LA'):
-        new_suffix = '.png'  # Mantener PNG si tiene transparencia
+    new_suffix = f".{optimized_format.lower()}" if optimized_format else '.jpg'
     return f"{path.stem}_optimizado{new_suffix}"
 
 
@@ -89,32 +87,35 @@ def main():
         progress_bar = st.progress(0)
         total_files = len(uploaded_files)
 
-        with st.status("Optimizando imágenes...", expanded=True) as status:
-            for idx, file in enumerate(uploaded_files):
-                try:
-                    if file.size > 50 * 1024 * 1024:
-                        st.error(f"Archivo {file.name} excede 50MB")
-                        continue
+        st.info("Optimizando imágenes...")
 
-                    original_size = file.size
-                    optimized_data, format_used = optimize_image(file)
+        for idx, file in enumerate(uploaded_files):
+            try:
+                if file.size > 50 * 1024 * 1024:
+                    st.error(f"Archivo {file.name} excede 50MB")
+                    continue
 
-                    if optimized_data and format_used:
-                        new_size = len(optimized_data)
-                        reduction = original_size - new_size
-                        total_reduction += reduction
+                original_size = file.size
+                optimized_data, format_used = optimize_image(file)
 
-                        new_name = process_filename(file.name)
-                        processed_images.append((new_name, optimized_data, original_size, new_size))
+                if optimized_data and format_used:
+                    new_size = len(optimized_data)
+                    reduction = original_size - new_size
+                    total_reduction += reduction
 
-                        progress_bar.progress((idx + 1) / total_files)
-                        st.write(f"✅ {file.name} optimizado ({reduction / 1024:.1f} KB ahorrados)")
+                    new_name = process_filename(file.name, format_used)
+                    processed_images.append((new_name, optimized_data, original_size, new_size))
 
-                except Exception as e:
-                    st.error(f"Error procesando {file.name}: {str(e)}")
+                    st.write(f"✅ {file.name} optimizado ({reduction / 1024:.1f} KB ahorrados)")
+                else:
+                    st.write(f"⚠️ {file.name} no se optimizó porque no se logró reducir el tamaño.")
 
-            status.update(label=f"¡Optimización completada! (Ahorro total: {total_reduction / 1024:.1f} KB)",
-                         state="complete")
+                progress_bar.progress((idx + 1) / total_files)
+
+            except Exception as e:
+                st.error(f"Error procesando {file.name}: {str(e)}")
+
+        st.success(f"¡Optimización completada! (Ahorro total: {total_reduction / 1024:.1f} KB)")
 
         if processed_images:
             # Mostrar resultados
@@ -139,10 +140,9 @@ def main():
                 label="📥 Descargar Todas las Imágenes",
                 data=zip_buffer.getvalue(),
                 file_name=f"imagenes_optimizadas_{datetime.now().strftime('%Y%m%d_%H%M')}.zip",
-                mime="application/zip",
-                type="primary"
+                mime="application/zip"
             )
 
 
 if __name__ == "__main__":
-    main()
+    main()