Update app.py

app.py

@@ -1,4 +1,5 @@
 import os
+import time
 import uuid
 from typing import List, Tuple, Optional, Union
 from PIL import Image
@@ -9,168 +10,221 @@ from dotenv import load_dotenv
 # Cargar las variables de entorno desde el archivo .env
 load_dotenv()
 
-# Configuración de claves
+print("google-generativeai:", genai.__version__)
+
+# Obtener la clave de la API de las variables de entorno
 GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")
+
+# Verificar que la clave de la API esté configurada
 if not GOOGLE_API_KEY:
     raise ValueError("GOOGLE_API_KEY is not set in environment variables.")
 
-genai.configure(api_key=GOOGLE_API_KEY)
-
-# Configuración general
-TITLE = """<h1 align="center">Gemini Playground ✨</h1>"""
-SUBTITLE = """<h2 align="center">Play with Gemini Pro and Gemini Pro Vision</h2>"""
-
-IMAGE_CACHE_DIRECTORY = "/tmp"
-IMAGE_WIDTH = 512
+# Configuración del modelo Gemini
+generation_config = {
+    "temperature": 1,
+    "top_p": 0.95,
+    "top_k": 40,
+    "max_output_tokens": 8192,
+    "response_mime_type": "text/plain",
+}
 
-# Función para preprocesar imágenes
-def preprocess_image(image: Image.Image) -> Optional[Image.Image]:
-    if image:
-        image_height = int(image.height * IMAGE_WIDTH / image.width)
-        return image.resize((IMAGE_WIDTH, image_height))
-
-# Función para guardar imágenes en caché
-def cache_pil_image(image: Image.Image) -> str:
-    image_filename = f"{uuid.uuid4()}.jpeg"
-    os.makedirs(IMAGE_CACHE_DIRECTORY, exist_ok=True)
-    image_path = os.path.join(IMAGE_CACHE_DIRECTORY, image_filename)
-    image.save(image_path, "JPEG")
-    return image_path
+genai.configure(api_key=GOOGLE_API_KEY)
 
-# Pestaña 1: Chatbot de solo texto con historial
+# Inicializar los modelos para ambas pestañas
+model_with_images = genai.GenerativeModel(
+    model_name="gemini-1.5-flash",
+    generation_config=generation_config
+)
+
+model_text_only = genai.GenerativeModel(
+    model_name="gemini-1.5-flash",
+    generation_config=generation_config
+)
+
+# Inicializar la sesión de chat para el chatbot sin imágenes
+chat_text_only = model_text_only.start_chat(history=[])
+
+# Función para transformar el historial de Gradio al formato de Gemini
+def transform_history(history):
+    new_history = []
+    for chat_entry in history:
+        new_history.append({"parts": [{"text": chat_entry[0]}], "role": "user"})
+        new_history.append({"parts": [{"text": chat_entry[1]}], "role": "model"})
+    return new_history
+
+# Función de respuesta que maneja el historial para el chatbot sin imágenes
 def bot_response(
     model_choice: str,
     system_instruction: str,
     text_prompt: str,
-    chatbot: List[Tuple[str, str]],
-) -> Tuple[List[Tuple[str, str]], str]:
+    chatbot: list,
+) -> Tuple[list, str]:
+    """
+    Envía el mensaje al modelo, obtiene la respuesta y actualiza el historial.
+    """
     if not text_prompt.strip():
         return chatbot, "Por favor, escribe un mensaje válido."
 
-    model = genai.GenerativeModel(
-        model_name=model_choice,
-        generation_config={
-            "temperature": 1,
-            "top_p": 0.95,
-            "top_k": 40,
-            "max_output_tokens": 8192,
-        },
-    )
-    chat = model.start_chat(history=chatbot)
-    chat.system_instruction = system_instruction
+    # Transformar el historial al formato que espera Gemini
+    transformed_history = transform_history(chatbot)
 
-    response = chat.send_message(text_prompt)
+    # Configurar el modelo
+    chat_text_only.history = transformed_history
+
+    # Enviar el mensaje y obtener la respuesta
+    response = chat_text_only.send_message(text_prompt)
     response.resolve()
 
-    chatbot.append((text_prompt, response.text))
+    # Obtener el texto generado por el modelo
+    generated_text = response.text
+
+    # Actualizar el historial con la pregunta y la respuesta
+    chatbot.append((text_prompt, generated_text))
+
     return chatbot, ""
 
-# Pestaña 2: Chatbot avanzado con imágenes
-def upload(files: Optional[List[gr.File]], chatbot: List[Tuple[str, str]]) -> List[Tuple[str, str]]:
-    if files:
-        for file in files:
-            image = Image.open(file.name).convert("RGB")
-            image_preview = preprocess_image(image)
-            if image_preview:
-                image_path = cache_pil_image(image_preview)
-                chatbot.append((f"Uploaded image: {image_path}", "Imagen cargada correctamente."))
+# Funciones para manejar el chatbot con imágenes
+def preprocess_image(image: Image.Image) -> Optional[Image.Image]:
+    if image:
+        image_height = int(image.height * 512 / image.width)
+        return image.resize((512, image_height))
+
+def cache_pil_image(image: Image.Image) -> str:
+    image_filename = f"{uuid.uuid4()}.jpeg"
+    os.makedirs("/tmp", exist_ok=True)
+    image_path = os.path.join("/tmp", image_filename)
+    image.save(image_path, "JPEG")
+    return image_path
+
+def upload(files: Optional[List[str]], chatbot: list) -> list:
+    for file in files:
+        image = Image.open(file).convert('RGB')
+        image_preview = preprocess_image(image)
+        if image_preview:
+            gr.Image(image_preview).render()
+        image_path = cache_pil_image(image)
+        chatbot.append(((image_path,), None))
     return chatbot
 
-def advanced_response(
-    text_prompt: str,
-    files: Optional[List[gr.File]],
+def user(text_prompt: str, chatbot: list):
+    if text_prompt:
+        chatbot.append((text_prompt, None))
+    return "", chatbot
+
+def bot(
+    files: Optional[List[str]],
     model_choice: str,
-    system_instruction: str,
-    chatbot: List[Tuple[str, str]],
+    system_instruction: Optional[str],
+    chatbot: list
 ):
-    if not text_prompt.strip() and not files:
-        chatbot.append(("", "Por favor, proporciona un mensaje o sube una imagen."))
-        yield chatbot
-        return
-
-    model = genai.GenerativeModel(
-        model_name=model_choice,
-        generation_config={
-            "temperature": 0.7,
-            "max_output_tokens": 8192,
-            "top_k": 10,
-            "top_p": 0.9,
-        },
+    if not GOOGLE_API_KEY:
+        raise ValueError("GOOGLE_API_KEY is not set.")
+
+    genai.configure(api_key=GOOGLE_API_KEY)
+    generation_config = genai.types.GenerationConfig(
+        temperature=0.7,
+        max_output_tokens=8192,
+        top_k=10,
+        top_p=0.9
     )
-    chat = model.start_chat(history=chatbot)
-    chat.system_instruction = system_instruction
 
-    if text_prompt:
-        chatbot.append((text_prompt, ""))
-    if files:
-        images = [cache_pil_image(preprocess_image(Image.open(file.name))) for file in files]
-        chatbot.append((f"Uploaded images: {', '.join(images)}", ""))
+    if not system_instruction:
+        system_instruction = "1"
 
-    response = chat.send_message(text_prompt)
-    response.resolve()
+    text_prompt = [chatbot[-1][0]] if chatbot and chatbot[-1][0] and isinstance(chatbot[-1][0], str) else []
+    image_prompt = [preprocess_image(Image.open(file).convert('RGB')) for file in files] if files else []
 
-    chatbot[-1] = (chatbot[-1][0], response.text)
-    yield chatbot
+    model_with_images = genai.GenerativeModel(
+        model_name=model_choice,
+        generation_config=generation_config,
+        system_instruction=system_instruction
+    )
 
-# Construcción de la interfaz
-def build_interface():
-    with gr.Blocks() as demo:
-        gr.HTML(TITLE)
-        gr.HTML(SUBTITLE)
+    response = model_with_images.generate_content(text_prompt + image_prompt, stream=True, generation_config=generation_config)
 
-        with gr.Tab("Pestaña 1: Chatbot Texto"):
-            model_dropdown_1 = gr.Dropdown(
-                choices=["gemini-1.5-flash", "gemini-2.0-flash-exp", "gemini-1.5-pro"],
-                value="gemini-1.5-flash",
-                label="Selecciona el modelo",
-            )
-            chatbot_1 = gr.Chatbot(label="Gemini", height=300)
-            system_instruction_1 = gr.Textbox(
-                placeholder="Escribe una instrucción para el sistema...",
-                label="Instrucción del sistema",
-                value="You are an assistant.",
-            )
+    chatbot[-1][1] = ""
+    for chunk in response:
+        for i in range(0, len(chunk.text), 10):
+            section = chunk.text[i:i + 10]
+            chatbot[-1][1] += section
+            time.sleep(0.01)
+            yield chatbot
 
-            with gr.Row():
-                text_input_1 = gr.Textbox(placeholder="Escribe un mensaje...", show_label=False)
-                run_button_1 = gr.Button(value="Enviar", variant="primary")
+# Interfaces
+TITLE = """<h1 align="center">Gemini Playground ✨</h1>"""
+SUBTITLE = """<h2 align="center">Play with Gemini Pro and Gemini Pro Vision</h2>"""
 
-            run_button_1.click(
-                fn=bot_response,
-                inputs=[model_dropdown_1, system_instruction_1, text_input_1, chatbot_1],
-                outputs=[chatbot_1, text_input_1],
+# Componentes comunes
+chatbot_component_with_images = gr.Chatbot(label='Gemini with Images', scale=2, height=300)
+chatbot_component_text_only = gr.Chatbot(label='Gemini Text Only', scale=2, height=300)
+text_prompt_component = gr.Textbox(placeholder="Message...", show_label=False, autofocus=True, scale=8)
+run_button_component = gr.Button(value="Run", variant="primary", scale=1)
+upload_button_component = gr.UploadButton(label="Upload Images", file_count="multiple", file_types=["image"], scale=1)
+model_choice_component = gr.Dropdown(
+    choices=["gemini-1.5-flash", "gemini-2.0-flash-exp", "gemini-1.5-pro"],
+    value="gemini-1.5-flash",
+    label="Select Model",
+    scale=2
+)
+system_instruction_component = gr.Textbox(
+    placeholder="Enter system instruction...",
+    show_label=True,
+    scale=8
+)
+
+with gr.Blocks() as demo:
+    gr.HTML(TITLE)
+    gr.HTML(SUBTITLE)
+    with gr.Tabs():
+        with gr.TabItem("Chatbot with Images"):
+            with gr.Column():
+                model_choice_component.render()
+                chatbot_component_with_images.render()
+                with gr.Row():
+                    text_prompt_component.render()
+                    upload_button_component.render()
+                    run_button_component.render()
+                with gr.Accordion("System Instruction", open=False):
+                    system_instruction_component.render()
+
+            run_button_component.click(
+                fn=user,
+                inputs=[text_prompt_component, chatbot_component_with_images],
+                outputs=[text_prompt_component, chatbot_component_with_images],
+                queue=False
+            ).then(
+                fn=bot,
+                inputs=[upload_button_component, model_choice_component, system_instruction_component, chatbot_component_with_images],
+                outputs=[chatbot_component_with_images],
             )
 
-        with gr.Tab("Pestaña 2: Chatbot con Imágenes"):
-            model_dropdown_2 = gr.Dropdown(
-                choices=["gemini-1.5-flash", "gemini-2.0-flash-exp", "gemini-1.5-pro"],
-                value="gemini-1.5-flash",
-                label="Selecciona el modelo",
-            )
-            chatbot_2 = gr.Chatbot(label="Gemini", height=300)
-            system_instruction_2 = gr.Textbox(
-                placeholder="Escribe una instrucción para el sistema...",
-                label="Instrucción del sistema",
+            upload_button_component.upload(
+                fn=upload,
+                inputs=[upload_button_component, chatbot_component_with_images],
+                outputs=[chatbot_component_with_images],
+                queue=False
             )
 
-            with gr.Row():
-                text_input_2 = gr.Textbox(placeholder="Mensaje o descripción...", show_label=False)
-                upload_button = gr.UploadButton(label="Subir Imágenes", file_count="multiple", file_types=["image"])
-                run_button_2 = gr.Button(value="Ejecutar", variant="primary")
-
-            run_button_2.click(
-                fn=advanced_response,
-                inputs=[text_input_2, upload_button, model_dropdown_2, system_instruction_2, chatbot_2],
-                outputs=[chatbot_2],
-            )
-            upload_button.upload(
-                fn=upload,
-                inputs=[upload_button, chatbot_2],
-                outputs=[chatbot_2],
+        with gr.TabItem("Chatbot Text Only"):
+            with gr.Column():
+                model_choice_component.render()
+                chatbot_component_text_only.render()
+                with gr.Row():
+                    text_prompt_component.render()
+                    run_button_component.render()
+                with gr.Accordion("System Instruction", open=False):
+                    system_instruction_component.render()
+
+            run_button_component.click(
+                fn=bot_response,
+                inputs=[model_choice_component, system_instruction_component, text_prompt_component, chatbot_component_text_only],
+                outputs=[chatbot_component_text_only, text_prompt_component],
             )
 
-    return demo
+            text_prompt_component.submit(
+                fn=bot_response,
+                inputs=[model_choice_component, system_instruction_component, text_prompt_component, chatbot_component_text_only],
+                outputs=[chatbot_component_text_only, text_prompt_component],
+            )
 
-if __name__ == "__main__":
-    demo = build_interface()
-    demo.launch(debug=True)
+demo.queue(max_size=99).launch(debug=True, show_error=True)