Update app.py

app.py

@@ -3,126 +3,148 @@ SUBTITLE = """<h2 align="center">Play with Gemini Pro and Gemini Pro Vision</h2>
 
 import os
 import time
-import uuid
 from typing import List, Tuple, Optional, Union
 
 import google.generativeai as genai
 import gradio as gr
-from PIL import Image
 from dotenv import load_dotenv
 
 # Cargar las variables de entorno desde el archivo .env
 load_dotenv()
 
-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.")
 
+# Configuración global
+genai.configure(api_key=GOOGLE_API_KEY)
 IMAGE_WIDTH = 512
-CHAT_HISTORY = List[Tuple[Optional[Union[Tuple[str], str]], Optional[str]]]
-
-def user(text_prompt: str, chatbot: CHAT_HISTORY):
-    if text_prompt:
+CHAT_HISTORY = List[Tuple[Optional[str], Optional[str]]]
+
+# Inicializar el modelo y la sesión de chat
+model_name_default = "gemini-1.5-flash"
+generation_config = genai.types.GenerationConfig(
+    temperature=0.7,
+    max_output_tokens=8192,
+    top_k=10,
+    top_p=0.9
+)
+model = genai.GenerativeModel(model_name=model_name_default, generation_config=generation_config)
+chat = model.start_chat(history=[])
+
+
+def transform_history(history: CHAT_HISTORY):
+    """
+    Transforma el historial del formato Gradio al formato esperado por Gemini.
+    """
+    new_history = []
+    for user_input, model_response in history:
+        if user_input:
+            new_history.append({"parts": [{"text": user_input}], "role": "user"})
+        if model_response:
+            new_history.append({"parts": [{"text": model_response}], "role": "model"})
+    return new_history
+
+
+def user_input_handler(text_prompt: str, chatbot: CHAT_HISTORY):
+    """
+    Agrega la entrada del usuario al historial y retorna la interfaz actualizada.
+    """
+    if text_prompt.strip():
         chatbot.append((text_prompt, None))
     return "", chatbot
 
-def bot(
+
+def bot_response_handler(
     model_choice: str,
-    system_instruction: Optional[str],  # Sistema de instrucciones opcional
-    chatbot: CHAT_HISTORY
+    system_instruction: Optional[str],
+    chatbot: CHAT_HISTORY,
 ):
+    """
+    Genera la respuesta del modelo basado en el historial y devuelve la interfaz actualizada.
+    """
+    global chat
+
     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
-    )
-
-    # Usar el valor por defecto para system_instruction si está vacío
-    if not system_instruction:
-        system_instruction = "1"  # O puedes poner un valor predeterminado como "No system instruction provided."
-
-    text_prompt = [chatbot[-1][0]] if chatbot and chatbot[-1][0] and isinstance(chatbot[-1][0], str) else []
-    
+    # Configurar el modelo y la instrucción del sistema
     model = genai.GenerativeModel(
         model_name=model_choice,
         generation_config=generation_config,
-        system_instruction=system_instruction
+        system_instruction=system_instruction or "Default instruction"
     )
+    
+    # Transformar el historial para la sesión del chat
+    chat.history = transform_history(chatbot)
+    
+    # Obtener el mensaje más reciente
+    user_message = chatbot[-1][0] if chatbot and chatbot[-1][0] else ""
+    
+    # Enviar el mensaje y procesar la respuesta
+    response = chat.send_message(user_message)
+    response.resolve()
 
-    response = model.generate_content(text_prompt, stream=True, generation_config=generation_config)
+    # Actualizar el historial con la respuesta del modelo
+    chatbot[-1] = (user_message, response.text)
 
-    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
+    # Devolver la respuesta por fragmentos para simular la experiencia de escritura
+    for i in range(len(response.text)):
+        time.sleep(0.01)
+        yield chatbot
 
-# Componente para el acordeón que contiene el cuadro de texto para la instrucción del sistema
-system_instruction_component = gr.Textbox(
-    placeholder="Enter system instruction...",
-    show_label=True,
-    scale=8
-)
 
-# Definir los componentes de entrada y salida
-chatbot_component = gr.Chatbot(label='Gemini', bubble_full_width=False, 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)
-model_choice_component = gr.Dropdown(
+# Componentes de la interfaz
+chatbot_component = gr.Chatbot(label="Gemini Chat", height=400)
+text_input_component = gr.Textbox(placeholder="Escribe tu mensaje aquí...", show_label=False)
+model_dropdown_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
+    value=model_name_default,
+    label="Selecciona el modelo",
 )
+system_instruction_component = gr.Textbox(
+    placeholder="Instrucción para el modelo...",
+    label="System Instruction",
+    optional=True,
+)
+run_button_component = gr.Button("Enviar")
 
-user_inputs = [text_prompt_component, chatbot_component]
-bot_inputs = [model_choice_component, system_instruction_component, chatbot_component]
-
-# Definir la interfaz de usuario
+# Layout de la interfaz
 with gr.Blocks() as demo:
     gr.HTML(TITLE)
     gr.HTML(SUBTITLE)
     with gr.Column():
-        # Campo de selección de modelo arriba
-        model_choice_component.render()
+        model_dropdown_component.render()
         chatbot_component.render()
         with gr.Row():
-            text_prompt_component.render()
+            text_input_component.render()
             run_button_component.render()
-
-        # Crear el acordeón para la instrucción del sistema al final
-        with gr.Accordion("System Instruction", open=False):  # Acordeón cerrado por defecto
+        with gr.Accordion("System Instruction", open=False):
             system_instruction_component.render()
 
+    # Conexiones de eventos
     run_button_component.click(
-        fn=user,
-        inputs=user_inputs,
-        outputs=[text_prompt_component, chatbot_component],
-        queue=False
+        user_input_handler,
+        inputs=[text_input_component, chatbot_component],
+        outputs=[text_input_component, chatbot_component],
+        queue=False,
     ).then(
-        fn=bot, inputs=bot_inputs, outputs=[chatbot_component],
+        bot_response_handler,
+        inputs=[model_dropdown_component, system_instruction_component, chatbot_component],
+        outputs=[chatbot_component],
     )
 
-    text_prompt_component.submit(
-        fn=user,
-        inputs=user_inputs,
-        outputs=[text_prompt_component, chatbot_component],
-        queue=False
+    text_input_component.submit(
+        user_input_handler,
+        inputs=[text_input_component, chatbot_component],
+        outputs=[text_input_component, chatbot_component],
+        queue=False,
     ).then(
-        fn=bot, inputs=bot_inputs, outputs=[chatbot_component],
+        bot_response_handler,
+        inputs=[model_dropdown_component, system_instruction_component, chatbot_component],
+        outputs=[chatbot_component],
     )
 
 # Lanzar la aplicación
-demo.queue(max_size=99).launch(debug=False, show_error=True)
+demo.queue(max_size=99).launch(debug=True, show_error=True)