Update app.py

app.py

@@ -1,6 +1,7 @@
 import streamlit as st
 from pptx import Presentation
-from pptx.util import Inches
+from pptx.util import Inches, Pt
+from pptx.enum.text import MSO_ANCHOR, MSO_AUTO_SIZE
 import requests
 from PIL import Image
 from io import BytesIO
@@ -12,24 +13,37 @@ import google.generativeai as genai
 
 # Configurar Gemini
 GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
+if not GEMINI_API_KEY:
+    st.error("GEMINI_API_KEY no encontrada. Por favor configúrala.")
+    st.stop()
 genai.configure(api_key=GEMINI_API_KEY)
 
 # Obtener la clave API de Pixabay desde los secretos de Streamlit
-PIXABAY_API_KEY = st.secrets["pixabay"]
+PIXABAY_API_KEY = st.secrets.get("pixabay")
+if not PIXABAY_API_KEY:
+    st.error("Clave API de Pixabay no encontrada en los secretos de Streamlit.")
+    st.stop()
 
 @st.cache_resource
 def get_gemini_model():
     return genai.GenerativeModel("gemini-1.5-flash")
 
 def extract_and_clean_json(text):
-    json_match = re.search(r'\{.*\}', text, re.DOTALL)
-    if json_match:
-        json_str = json_match.group()
-        json_str = re.sub(r'[\n\t\r]', '', json_str)
-        json_str = re.sub(r',\s*}', '}', json_str)
-        json_str = re.sub(r',\s*]', ']', json_str)
-        return json_str
-    return None
+    # Intenta encontrar JSON entre ```json ... ``` o directamente
+    match = re.search(r"```json\s*(\{.*?\})\s*```", text, re.DOTALL)
+    if match:
+        json_str = match.group(1)
+    else:
+        json_match = re.search(r'\{.*\}', text, re.DOTALL)
+        if json_match:
+            json_str = json_match.group()
+        else:
+            return None
+            
+    json_str = re.sub(r'[\n\t\r]', '', json_str)
+    json_str = re.sub(r',\s*}', '}', json_str)
+    json_str = re.sub(r',\s*]', ']', json_str)
+    return json_str
 
 def generate_presentation_content(topic, client, max_retries=3):
     prompt = f"""Genera una presentación de PowerPoint sobre el tema: "{topic}".
@@ -51,68 +65,194 @@ def generate_presentation_content(topic, client, max_retries=3):
     }}
 
     No incluyas ningún otro texto, explicación o saludo. Solo el JSON.
+    Asegúrate de que el contenido sea conciso y adecuado para una diapositiva.
+    Evita usar caracteres especiales o comillas dentro de los títulos o contenidos que puedan romper el JSON.
+    Usa comillas dobles para las claves y los valores string del JSON.
     """
     
     for attempt in range(max_retries):
         try:
             response = client.generate_content(prompt).text
+            # st.text(f"Respuesta cruda del modelo (intento {attempt + 1}):\n{response}") # Para depuración
             json_str = extract_and_clean_json(response)
             if json_str:
                 slides_data = json.loads(json_str)
-                if 'slides' in slides_data and len(slides_data['slides']) == 9:
+                if 'slides' in slides_data and isinstance(slides_data['slides'], list) and len(slides_data['slides']) == 9:
+                    # Validar que cada slide tenga title y content
+                    for s in slides_data['slides']:
+                        if not ('title' in s and 'content' in s):
+                            raise ValueError("Estructura de slide incorrecta: falta title o content.")
                     return slides_data['slides']
-            raise ValueError("JSON inválido o estructura incorrecta")
+                else:
+                    raise ValueError(f"Estructura JSON incorrecta o número de diapositivas no es 9. Diapositivas encontradas: {len(slides_data.get('slides', [])) if 'slides' in slides_data else 'Key slides no encontrada'}")
+            else:
+                raise ValueError("No se pudo extraer JSON válido de la respuesta.")
         except (json.JSONDecodeError, ValueError) as e:
+            st.warning(f"Intento {attempt + 1}/{max_retries} fallido al procesar la respuesta: {str(e)}")
             if attempt == max_retries - 1:
-                st.error(f"Error al generar el contenido después de {max_retries} intentos: {str(e)}")
-                st.text("Última respuesta del modelo:")
-                st.code(response)
+                st.error(f"Error al generar el contenido después de {max_retries} intentos.")
+                st.text("Última respuesta del modelo (puede ser muy larga):")
+                st.code(response[:1000] + "..." if len(response) > 1000 else response) # Muestra solo una parte
                 return None
             else:
-                st.warning(f"Intento {attempt + 1} fallido. Reintentando...")
+                st.warning("Reintentando...")
     return None
 
 def buscar_imagen_pixabay(query):
-    url = f"https://pixabay.com/api/?key={PIXABAY_API_KEY}&q={requests.utils.quote(query)}&image_type=photo&per_page=10"
-    response = requests.get(url)
-    data = response.json()
-
-    if data.get('hits'):
-        image_url = data['hits'][0]['webformatURL']
-        image_response = requests.get(image_url)
-        return Image.open(BytesIO(image_response.content))
+    if not PIXABAY_API_KEY:
+        print("Pixabay API Key no configurada.")
+        return None
+    url = f"https://pixabay.com/api/?key={PIXABAY_API_KEY}&q={requests.utils.quote(query)}&image_type=photo&per_page=3&safesearch=true"
+    try:
+        response = requests.get(url, timeout=10)
+        response.raise_for_status() # Lanza excepción para errores HTTP
+        data = response.json()
+
+        if data.get('hits') and len(data['hits']) > 0:
+            # Intenta obtener una imagen con buena resolución pero no excesivamente grande
+            # priorizando webformatURL o largeImageURL si está disponible
+            image_info = data['hits'][0]
+            image_url = image_info.get('largeImageURL', image_info.get('webformatURL'))
+            if not image_url: return None
+
+            image_response = requests.get(image_url, timeout=10)
+            image_response.raise_for_status()
+            
+            # Abrir con PIL para verificar y potencialmente convertir/redimensionar
+            img = Image.open(BytesIO(image_response.content))
+            img.verify() # Verifica que sea una imagen válida
+            # Reabrir después de verify
+            img = Image.open(BytesIO(image_response.content))
+            return img
+    except requests.exceptions.RequestException as e:
+        print(f"Error en la solicitud a Pixabay ({query}): {e}")
+    except Exception as e:
+        print(f"Error procesando imagen de Pixabay ({query}): {e}")
     return None
 
-def create_powerpoint(slides, template_path):
+def create_powerpoint(slides_content, template_path):
     prs = Presentation(template_path)
+
+    # Dimensiones típicas de una diapositiva 16:9 (en EMUs, convertidas a Inches)
+    # PowerPoint usa 914400 EMUs por pulgada.
+    # Ancho: 10 pulgadas, Alto: 5.625 pulgadas (para layout 16:9)
+    # O más común: Ancho 10 pulgadas, Alto 7.5 pulgadas (para layout 4:3)
+    # Las plantillas suelen definir esto. Usaremos prs.slide_width y prs.slide_height
     
-    for slide_data in slides:
-        slide = prs.slides.add_slide(prs.slide_layouts[1])
-        title_shape = slide.shapes.title
-        content_shape = slide.placeholders[1] if len(slide.placeholders) > 1 else None
-
-        if title_shape:
-            title_shape.text = slide_data['title']
-        if content_shape:
-            content_shape.text = slide_data['content']
+    slide_width = prs.slide_width
+    slide_height = prs.slide_height
+
+    for i, slide_data in enumerate(slides_content):
+        # Usar layout 1 (Título y Contenido) consistentemente
+        slide_layout = prs.slide_layouts[1] 
+        slide = prs.slides.add_slide(slide_layout)
+
+        # Título
+        if slide.shapes.title:
+            slide.shapes.title.text = slide_data['title']
+        
+        # Contenido y Espacio para Imagen
+        # Asumimos que placeholder 1 es el cuerpo del contenido para el layout 1
+        content_placeholder = None
+        if slide.placeholders and len(slide.placeholders) > 1 and slide.placeholders[1]:
+             content_placeholder = slide.placeholders[1]
+        
+        # --- Definir áreas para texto e imagen ---
+        # Margen general
+        margin = Inches(0.3)
+        
+        # Área de imagen (derecha de la diapositiva)
+        img_area_width = slide_width * 0.40 # 40% para la imagen
+        img_area_left = slide_width - img_area_width - margin
+        
+        # Área de texto (izquierda de la diapositiva)
+        text_area_width = slide_width - img_area_width - (2 * margin) # Ancho restante menos márgenes
+        text_area_left = margin
+
+        # Altura y Top común para texto e imagen (debajo del título)
+        # El título suele ocupar hasta Inches(1.5) o Inches(1.8) desde arriba
+        common_top = Inches(1.6)
+        common_height = slide_height - common_top - margin
+
+        if content_placeholder:
+            content_placeholder.left = text_area_left
+            content_placeholder.top = common_top
+            content_placeholder.width = text_area_width
+            content_placeholder.height = common_height
+            
+            tf = content_placeholder.text_frame
+            tf.clear() # Limpiar cualquier texto preexistente del placeholder
+            p = tf.add_paragraph()
+            p.text = slide_data['content']
+            tf.word_wrap = True
+            tf.auto_size = MSO_AUTO_SIZE.TEXT_TO_FIT_SHAPE # Ajustar texto al contenedor
+            # Ajustar anclaje vertical si es necesario
+            # tf.vertical_anchor = MSO_ANCHOR.MIDDLE 
         else:
-            txBox = slide.shapes.add_textbox(Inches(0.5), Inches(1.5), Inches(9), Inches(5))
+            # Fallback si no hay placeholder de contenido (menos ideal)
+            txBox = slide.shapes.add_textbox(text_area_left, common_top, text_area_width, common_height)
             tf = txBox.text_frame
             tf.text = slide_data['content']
+            tf.word_wrap = True
+            tf.auto_size = MSO_AUTO_SIZE.TEXT_TO_FIT_SHAPE
+
 
-        # Buscar e insertar imagen
+        # --- Buscar e insertar imagen ---
         try:
-            img = buscar_imagen_pixabay(slide_data['title'])
-            if img:
-                img_path = "/tmp/temp_img.jpg"
-                img.save(img_path)
-                slide.shapes.add_picture(img_path, Inches(5), Inches(1.5), width=Inches(4))
+            # Mejorar la query para la imagen
+            first_sentence = slide_data['content'].split('.')[0] if '.' in slide_data['content'] else slide_data['content'][:70]
+            image_query = f"{slide_data['title']} {first_sentence}"
+            
+            pil_image = buscar_imagen_pixabay(image_query)
+
+            if pil_image:
+                # Convertir imagen PIL a BytesIO para python-pptx
+                img_byte_arr = io.BytesIO()
+                # Guardar en el formato original si es posible, o default a PNG/JPEG
+                # Asegurarse que el formato sea compatible (JPEG, PNG, GIF, TIFF, EMF, WMF)
+                img_format = pil_image.format if pil_image.format in ['JPEG', 'PNG', 'GIF'] else 'PNG'
+                if img_format == 'JPEG' and pil_image.mode == 'RGBA': # JPEG no soporta alpha
+                    pil_image = pil_image.convert('RGB')
+                
+                pil_image.save(img_byte_arr, format=img_format)
+                img_byte_arr.seek(0)
+
+                # Calcular dimensiones de la imagen manteniendo aspect ratio para que quepa en el área
+                img_native_width, img_native_height = pil_image.size
+                
+                # Área disponible para la imagen
+                available_width = img_area_width
+                available_height = common_height
+
+                ratio_w = available_width / Inches(img_native_width / 96) # Suponiendo 96 DPI para conversión px a inches
+                ratio_h = available_height / Inches(img_native_height / 96)
+                
+                # Escalar manteniendo el aspect ratio
+                scale_ratio = min(ratio_w, ratio_h) # Usar el ratio más pequeño para que quepa
+                
+                pic_width = Inches((img_native_width / 96) * scale_ratio)
+                pic_height = Inches((img_native_height / 96) * scale_ratio)
+
+                # Centrar la imagen en su área designada
+                pic_left = img_area_left + (available_width - pic_width) / 2
+                pic_top = common_top + (available_height - pic_height) / 2
+                
+                slide.shapes.add_picture(img_byte_arr, pic_left, pic_top, width=pic_width, height=pic_height)
         except Exception as e:
-            print(f"No se pudo insertar imagen: {e}")
+            print(f"No se pudo procesar o insertar imagen para slide {i+1} ('{slide_data['title']}'): {e}")
+            # st.warning(f"No se pudo insertar imagen para slide '{slide_data['title']}': {e}")
+
+    # Agregar diapositiva final de agradecimiento (sin imagen)
+    final_slide_layout = prs.slide_layouts[1] # O un layout de solo título si existe (ej. layout 5)
+    final_slide = prs.slides.add_slide(final_slide_layout)
+    if final_slide.shapes.title:
+        final_slide.shapes.title.text = "¡Gracias por su atención!"
     
-    # Agregar diapositiva final
-    final_slide = prs.slides.add_slide(prs.slide_layouts[1])
-    final_slide.shapes.title.text = "Gracias"
+    # Limpiar el placeholder de contenido si existe en la diapositiva final y no se usa
+    if len(final_slide.placeholders) > 1 and final_slide.placeholders[1]:
+        content_ph = final_slide.placeholders[1]
+        sp = content_ph.element
+        sp.getparent().remove(sp) # Elimina el placeholder de contenido
     
     pptx_buffer = io.BytesIO()
     prs.save(pptx_buffer)
@@ -120,47 +260,86 @@ def create_powerpoint(slides, template_path):
     return pptx_buffer
 
 def main():
-    st.title("PowerPoint Mágico con el Búho")
+    st.set_page_config(page_title="PowerPoint Mágico", layout="wide")
+    st.title("✨ PowerPoint Mágico con el Búho 🦉")
+    st.markdown("Genera presentaciones impactantes con IA y un toque de magia.")
 
     client = get_gemini_model()
 
-    topic = st.text_input("Por favor, ingrese el tema de la presentación:")
+    topic = st.text_input("📝 Por favor, ingrese el tema de la presentación:", placeholder="Ej: El futuro de la inteligencia artificial")
 
-    template_options = {
-        "Simple": "PLANTILLAS/Simple.pptx",
-        "Corporativo": "PLANTILLAS/Corporativo.pptx",
-        "Moderno": "PLANTILLAS/Moderno.pptx"
-    }
+    # Asegurarse que el directorio PLANTILLAS existe
+    plantillas_dir = "PLANTILLAS"
+    if not os.path.exists(plantillas_dir):
+        os.makedirs(plantillas_dir)
+        st.info(f"Directorio '{plantillas_dir}' creado. Por favor, añada sus plantillas .pptx allí.")
 
-    selected_template = st.selectbox("Seleccione una plantilla", list(template_options.keys()))
+    # Listar plantillas disponibles
+    try:
+        available_templates = [f for f in os.listdir(plantillas_dir) if f.endswith(".pptx")]
+    except FileNotFoundError:
+        available_templates = []
 
-    if st.button("Generar Presentación"):
-        if topic:
-            try:
-                with st.spinner("Generando contenido de la presentación..."):
-                    slides = generate_presentation_content(topic, client)
+    if not available_templates:
+        st.warning(f"No se encontraron plantillas .pptx en el directorio '{plantillas_dir}'. "
+                   "Se usará una presentación por defecto. Para mejores resultados, añada plantillas.")
+        # Crear una plantilla por defecto si no hay ninguna para que el código no falle
+        default_prs = Presentation()
+        default_template_path = os.path.join(plantillas_dir, "default.pptx")
+        default_prs.save(default_template_path)
+        available_templates.append("default.pptx")
 
-                if slides:
-                    template_path = template_options[selected_template]
-                    if not os.path.exists(template_path):
-                        st.error(f"No se encontró la plantilla: {template_path}")
-                        return
 
-                    with st.spinner("Creando archivo PowerPoint..."):
-                        pptx_buffer = create_powerpoint(slides, template_path)
+    template_options = {os.path.splitext(t)[0]: os.path.join(plantillas_dir, t) for t in available_templates}
+    
+    if not template_options: # Doble chequeo por si la creación de default falló
+        st.error("Error crítico: No hay plantillas disponibles y no se pudo crear una por defecto.")
+        st.stop()
 
-                    st.success("¡Presentación generada con éxito!")
+    selected_template_name = st.selectbox("🎨 Seleccione una plantilla:", list(template_options.keys()))
 
+    if st.button("🚀 Generar Presentación", type="primary"):
+        if topic and selected_template_name:
+            template_path = template_options[selected_template_name]
+            if not os.path.exists(template_path):
+                st.error(f"No se encontró la plantilla seleccionada: {template_path}")
+                return
+
+            progress_bar = st.progress(0)
+            status_text = st.empty()
+
+            status_text.text("🧠 Generando contenido de la presentación con Gemini...")
+            slides_content = generate_presentation_content(topic, client)
+            progress_bar.progress(50)
+
+            if slides_content:
+                status_text.text("🖼️ Añadiendo imágenes y creando archivo PowerPoint...")
+                try:
+                    pptx_buffer = create_powerpoint(slides_content, template_path)
+                    progress_bar.progress(100)
+                    status_text.success("¡Presentación generada con éxito!")
+
+                    clean_topic = re.sub(r'[^\w\s-]', '', topic).strip().replace(' ', '_')
+                    file_name = f"{clean_topic}_{selected_template_name}_presentacion.pptx"
+                    
                     st.download_button(
-                        label="Descargar Presentación",
+                        label="📥 Descargar Presentación",
                         data=pptx_buffer,
-                        file_name=f"{topic.replace(' ', '_')}_{selected_template}_presentacion.pptx",
+                        file_name=file_name,
                         mime="application/vnd.openxmlformats-officedocument.presentationml.presentation"
                     )
-            except Exception as e:
-                st.error(f"Ocurrió un error al generar la presentación: {str(e)}")
+                except Exception as e:
+                    progress_bar.progress(100) # Completar barra incluso en error
+                    status_text.error(f"Ocurrió un error al crear el archivo PowerPoint: {str(e)}")
+                    st.exception(e) # Muestra el traceback completo para depuración
+            else:
+                progress_bar.progress(100)
+                status_text.error("No se pudo generar el contenido para la presentación.")
         else:
-            st.warning("Por favor, ingrese un tema para la presentación.")
+            if not topic:
+                st.warning("⚠️ Por favor, ingrese un tema para la presentación.")
+            if not selected_template_name:
+                st.warning("⚠️ Por favor, seleccione una plantilla.")
 
 if __name__ == "__main__":
-    main()
+    main()