import streamlit as st
import cloudinary
import cloudinary.uploader
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 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() # 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):
"""
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) # Regresar al inicio
return file_size <= max_size_mb
def cleanup_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.
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")
return None
try:
image.seek(0)
image_name = getattr(image, 'name', '')
if not check_file_size(image, 10):
st.error(f"{image_name} excede el límite de 10MB")
return None
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=[transformation]
)
processed_url = response.get('secure_url')
processed_image = requests.get(processed_url).content
# Limpia el recurso procesado en Cloudinary
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")
with st.expander("📌 Instrucciones de uso", expanded=True):
st.markdown("""
**Recorta y redimensiona imágenes inteligentemente con Cloudinary**
**Formatos soportados:**
✅ PNG, JPG, JPEG, WEBP
**Características principales:**
- 🔍 Detección automática de rostros (opción 'face'/'faces')
- 🖼️ Mantenimiento de transparencia en PNG
- 📐 Redimensionado preciso con diferentes modos de gravedad
- 🚀 Procesamiento por lotes y descarga en ZIP
**Pasos para usar:**
1. ⚙️ Configura dimensiones deseadas y parámetros de recorte
2. 🎯 Selecciona el tipo de gravedad y el DPR (entre 1 y 3)
3. 📤 Sube tus imágenes (máx. 10MB c/u)
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)
with col2:
height = st.number_input("Alto (px)", value=460, min_value=100, max_value=3000)
with col3:
gravity_option = st.selectbox(
"Gravedad",
["auto", "center", "face", "faces", "north", "south", "east", "west"],
help="Configura cómo se enfocará el recorte en la imagen"
)
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'],
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("✨ 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)
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, 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:
zip_file.writestr(f"procesada_{name}", img_bytes)
st.download_button(
label="📥 Descargar Todas",
data=zip_buffer.getvalue(),
file_name="imagenes_procesadas.zip",
mime="application/zip"
)
if __name__ == "__main__":
main()