Actualizar app.py

app.py

@@ -3,9 +3,11 @@ import requests
 import json
 import os
 import random
+import base64
+import io
+from PIL import Image
 from typing import List, Optional
 
-# Tu clase generadora de prompts
 class HyperrealisticPromptGenerator:
     def __init__(self):
         self.ROLES = [
@@ -83,7 +85,6 @@ class HyperrealisticPromptGenerator:
     def _choose_random(self, options: List[str]) -> str:
         return random.choice(options)
 
-    # CORRECCIÓN DE SYNTAX ERROR: Uso de f-string con triple comilla
     def generate_single_prompt(self, role: Optional[str] = None) -> str:
         selected_role = role if role else self._choose_random(self.ROLES)
         age = self._choose_random(self.AGES)
@@ -93,172 +94,169 @@ class HyperrealisticPromptGenerator:
         pose = self._choose_random(self.POSES)
         setting = self._choose_random(self.SETTINGS)
         atmosphere = self._choose_random(self.ATMOSPHERES)
-        
-        prompt = f"""```
-Role: {selected_role}
-Age: {age}
-Hair: {hair_style} in {hair_color}
-Eyes: {eye_color} with expressive, captivating gaze
-Pose: {pose}
-Environment: {setting}
-Atmosphere: {atmosphere}
-Outfit: {self.CONDITION_FIXED}
-
-Technical specs:
-{self.TECHNICAL_DETAILS}
-```"""
-        return prompt
+        return (
+            f"```
+            f"Eyes: {eye_color}\nPose: {pose}\nEnvironment: {setting}\nAtmosphere: {atmosphere}\n"
+            f"Outfit: {self.CONDITION_FIXED}\nTechnical specs: {self.TECHNICAL_DETAILS}\n```"
+        )
 
     def generate_prompt_automatic(self):
-        # Simple método para generación automática sin rol pasado
         return self.generate_single_prompt()
 
-# Instancia del generador
 gen = HyperrealisticPromptGenerator()
 
-# Configuración API SambaNova
 API_KEY = os.getenv("SAMBANOVA_API_KEY")
 API_URL = "https://api.sambanova.ai/v1/chat/completions"
-headers = {
-    "Authorization": f"Bearer {API_KEY}",
-    "Content-Type": "application/json",
-}
+headers = {"Authorization": f"Bearer {API_KEY}", "Content-Type": "application/json"}
 
-def analizar_imagen_y_generar_prompt(image_url_or_base64):
-    # Se envía la imagen para obtener una descripción en inglés
+def process_image(image):
+    if image is None:
+        return None
+    buffered = io.BytesIO()
+    image.save(buffered, format="PNG")
+    return base64.b64encode(buffered.getvalue()).decode("utf-8")
+
+def analizar_imagen_y_generar_prompt(image_base64):
     if not API_KEY:
-        return "Error: La variable de entorno SAMBANOVA_API_KEY no está configurada."
-        
+        return "``````"
     messages = [
-        {"role": "system", "content": "You are an assistant that describes images in detailed English."},
-        {"role": "user", "content": [
-            {"type": "image_url", "image_url": {"url": image_url_or_base64}},
-            {"type": "text", "text": "Provide a detailed English description of this image to use as a prompt."},
-        ]}
+        {"role": "system", "content": "Describe images in detailed English."},
+        {
+            "role": "user", "content": [
+                {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{image_base64}"}},
+                {"type": "text", "text": "Provide a detailed English description for a prompt."}
+            ]
+        }
     ]
-    json_data = {
-        "model": "Llama-4-Maverick-17B-128E-Instruct",
-        "messages": messages,
-        "stream": False,
-    }
+    json_data = {"model": "Llama-4-Maverick-17B-128E-Instruct", "messages": messages, "stream": False}
     try:
         response = requests.post(API_URL, headers=headers, json=json_data)
         response.raise_for_status()
-        resp_json = response.json()
-        text_resp = resp_json["choices"][0]["message"]["content"]
-        
-        # CORRECCIÓN DE SYNTAX ERROR: Envuelve la respuesta en un bloque de código markdown
-        prompt = f"```\n{text_resp}\n```"
-        return prompt
+        text_resp = response.json()["choices"][0]["message"]["content"]
+        return f"``````"
     except Exception as e:
-        return f"Error al analizar imagen y generar prompt: {e}"
+        return f"``````"
+
+def chat_sambanova(user_message, image_input, auto_mode, chat_history, loading_state):
+    updated_history = chat_history[:] if chat_history else []
+    image_base64 = process_image(image_input) if image_input else None
+
+    # Indicador de carga
+    loading_state = "Procesando..."
+    yield "", updated_history, "", loading_state  # Limpiar input, actualizar chat, error vacío, carga activo
 
-def chat_sambanova(user_message, image_input, auto_mode, chat_history):
-    updated_history = chat_history.copy()
-    
     if not API_KEY:
-        error_msg = "Error: La variable de entorno SAMBANOVA_API_KEY no está configurada."
-        updated_history.append((user_message if user_message else "Intento de interacción", error_msg))
-        yield "", updated_history
+        error_msg = "Error: SAMBANOVA_API_KEY no configurada."
+        updated_history.append((user_message, error_msg))
+        yield "", updated_history, error_msg, ""
         return
 
-    if auto_mode and image_input:
-        # Modo automático: analizar imagen y generar prompt automáticamente
-        prompt = analizar_imagen_y_generar_prompt(image_input)
-        
-        ai_msg = f"IA - Prompt automático generado:\n{prompt}"
-        user_display = user_message if user_message else "Análisis de imagen automático"
-        updated_history.append((user_display, ai_msg))
-        
-        yield "", updated_history
+    if auto_mode and image_base64:
+        prompt = analizar_imagen_y_generar_prompt(image_base64)
+        updated_history.append((user_message or "Análisis automático", f"IA - Prompt generado:\n{prompt}"))
+        yield "", updated_history, "", ""
         return
 
-    # Modo chat manual: enviar mensaje a SambaNova API
     messages = [{"role": "system", "content": "Eres un asistente útil"}]
     for user_msg, ai_msg in updated_history:
-        # Si el mensaje es una tupla y es nuestro prompt interno, lo ignoramos para el contexto
-        if isinstance(user_msg, str) and user_msg.startswith("IA - Prompt automático generado"):
-             continue
-        
         messages.append({"role": "user", "content": [{"type": "text", "text": user_msg}]})
         messages.append({"role": "assistant", "content": ai_msg})
 
     user_content = [{"type": "text", "text": user_message}]
-    if image_input:
-        user_content.append({"type": "image_url", "image_url": {"url": image_input}})
+    if image_base64:
+        user_content.append({"type": "image_url", "image_url": {"url": f"data:image/png;base64,{image_base64}"}})
     messages.append({"role": "user", "content": user_content})
 
-    json_data = {
-        "model": "Llama-4-Maverick-17B-128E-Instruct",
-        "messages": messages,
-        "stream": True,
-    }
+    json_data = {"model": "Llama-4-Maverick-17B-128E-Instruct", "messages": messages, "stream": True}
 
     try:
         response = requests.post(API_URL, headers=headers, json=json_data, stream=True)
         response.raise_for_status()
-
         collected_text = ""
         updated_history.append((user_message, ""))
 
         for line in response.iter_lines(decode_unicode=True):
-            if line:
-                if line.startswith("data: "):
-                    json_str = line[len("data: "):]
-                    if json_str == "[DONE]":
-                        break
-                    try:
-                        data = json.loads(json_str)
-                        delta = data.get("choices", [{}])[0].get("delta", {})
-                        text_fragment = delta.get("content", "")
-
-                        collected_text += text_fragment
-
-                        if updated_history:
-                            updated_history[-1] = (updated_history[-1][0], collected_text)
+            if line.startswith("data: "):
+                json_str = line[len("data: "):]
+                if json_str == "[DONE]":
+                    break
+                try:
+                    data = json.loads(json_str)
+                    delta = data.get("choices", [{}])[0].get("delta", {})
+                    text_fragment = delta.get("content", "")
+                    collected_text += text_fragment
+                    updated_history[-1] = (user_message, collected_text)
+                    yield "", updated_history, "", "Procesando..."
+                except json.JSONDecodeError:
+                    continue
+        yield "", updated_history, "", ""
+    except requests.exceptions.HTTPError as http_err:
+        error_msg = f"Error HTTP {http_err.response.status_code}: {http_err.response.text}"
+        if updated_history:
+            updated_history[-1] = (user_message, error_msg)
+        yield "", updated_history, error_msg, ""
+    except requests.exceptions.ConnectionError:
+        error_msg = "Error: No se pudo conectar con la API de SambaNova. Verifica tu conexión."
+        if updated_history:
+            updated_history[-1] = (user_message, error_msg)
+        yield "", updated_history, error_msg, ""
+    except requests.exceptions.Timeout:
+        error_msg = "Error: La solicitud a la API timed out."
+        if updated_history:
+            updated_history[-1] = (user_message, error_msg)
+        yield "", updated_history, error_msg, ""
+    except Exception as e:
+        error_msg = f"Error inesperado: {str(e)}"
+        if updated_history:
+            updated_history[-1] = (user_message, error_msg)
+        yield "", updated_history, error_msg, ""
 
-                        yield "", updated_history
-                    except json.JSONDecodeError:
-                        continue
-                        
-        yield "", updated_history
-                        
-    except requests.exceptions.RequestException as err:
-        error_msg = f"Error de conexión con SambaNova: {err}"
-        if not updated_history or updated_history[-1][0] != user_message:
-            updated_history.append((user_message, error_msg))
-        else:
-            updated_history[-1] = (updated_history[-1][0], error_msg)
-        yield "", updated_history
-        
 def generar_prompt_interno():
-    return gen.generate_prompt_automatic()
+    return gen.generate_prompt_automatic(), ""
 
 with gr.Blocks() as demo:
     gr.Markdown("# Hyperrealistic Prompt Generator & Chatbot")
-    
     chat_history = gr.State([])
-    # CORRECCIÓN DE ADVERTENCIA: Se añade type='messages'
+    error_display = gr.Textbox(label="Mensajes de error", interactive=False, visible=True)
+    loading_state = gr.State("")
+
     chatbot = gr.Chatbot(label="Chatbot IA (SambaNova - Llama-4 Maverick)", type='messages')
-    
+    prompt_output = gr.Markdown(label="Prompt Generado", elem_classes=["prompt-output"])
     with gr.Row():
         msg = gr.Textbox(label="Escribe tu mensaje", scale=4)
-        img_input = gr.Textbox(label="Imagen base64 o URL (opcional)", placeholder="Pega aquí la imagen o URL", scale=2)
-        
+        img_input = gr.Image(label="Subir imagen (opcional)", type="pil", scale=2)
     with gr.Row():
-        auto_mode = gr.Checkbox(label="Modo automático (generar prompt auto desde imagen)", value=False)
+        auto_mode = gr.Checkbox(label="Modo automático (generar prompt desde imagen)", value=False)
         btn_send = gr.Button("Enviar mensaje", variant="primary")
-        # CORRECCIÓN DE FUNCIÓN INCOMPLETA: Se llama a generar_prompt_interno
-        btn_gen_prompt = gr.Button("Generar prompt automático interno (al cuadro de texto)", variant="secondary")
-
-    # Eventos
-    btn_send.click(chat_sambanova, inputs=[msg, img_input, auto_mode, chat_history], outputs=[msg, chatbot, chat_history])
-    msg.submit(chat_sambanova, inputs=[msg, img_input, auto_mode, chat_history], outputs=[msg, chatbot, chat_history])
+        btn_gen_prompt = gr.Button("Generar prompt automático", variant="secondary")
+        copy_button = gr.Button("Copiar Prompt")
+    with gr.Row():
+        loading = gr.Markdown(value=lambda x: f"**{x}**" if x else "", label="Estado")
 
-    # El botón genera el prompt y lo coloca en el cuadro de texto 'msg'
-    btn_gen_prompt.click(generar_prompt_interno, inputs=[], outputs=[msg])
+    btn_send.click(
+        fn=chat_sambanova,
+        inputs=[msg, img_input, auto_mode, chat_history, loading_state],
+        outputs=[msg, chatbot, chat_history, error_display, loading]
+    )
+    msg.submit(
+        fn=chat_sambanova,
+        inputs=[msg, img_input, auto_mode, chat_history, loading_state],
+        outputs=[msg, chatbot, chat_history, error_display, loading]
+    )
+    btn_gen_prompt.click(
+        fn=generar_prompt_interno,
+        inputs=[],
+        outputs=[msg, prompt_output]
+    )
+    copy_button.click(
+        fn=None,
+        _js="() => { navigator.clipboard.writeText(document.querySelector('.prompt-output').innerText); }",
+        outputs=None
+    )
 
-# CORRECCIÓN DE INICIALIZACIÓN: Esto inicia el servidor Gradio, esencial para el despliegue
 if __name__ == "__main__":
-    demo.launch() 
-    
+    try:
+        demo.launch()
+    except Exception as e:
+        print(f"Error al iniciar Gradio: {str(e)}")
+