Update app.py

app.py

@@ -2,6 +2,7 @@ TITLE = """<h1 align="center">Gemini Playground ✨</h1>"""
 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
 
@@ -26,46 +27,11 @@ IMAGE_CACHE_DIRECTORY = "/tmp"
 IMAGE_WIDTH = 512
 CHAT_HISTORY = List[Tuple[Optional[Union[Tuple[str], str]], Optional[str]]]
 
-# Función para transformar el historial del chat
-def transform_history(history: CHAT_HISTORY):
-    """
-    Transforma el historial del chat en el formato necesario para el modelo.
-    """
-    transformed = []
-    for user_input, bot_response in history:
-        if user_input:
-            transformed.append({"role": "user", "content": user_input})
-        if bot_response:
-            transformed.append({"role": "assistant", "content": bot_response})
-    return transformed
-
-# Función de generación de respuesta
-def response(message: str, history: CHAT_HISTORY, model: genai.GenerativeModel):
-    """
-    Genera una respuesta basada en el historial del chat y el mensaje del usuario.
-    """
-    # Crear el input para el modelo basado en el historial y el mensaje del usuario
-    input_text = "\n".join(
-        [
-            f"User: {item[0]}" if item[0] else f"Bot: {item[1]}"
-            for item in history
-        ]
-    )
-    input_text += f"\nUser: {message}"
-    
-    # Generar la respuesta
-    model_response = model.generate(input_text)
-    
-    # Retornar la respuesta generada
-    return model_response.text
-
-# Preprocesamiento de 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))
 
-# 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)
@@ -73,28 +39,26 @@ def cache_pil_image(image: Image.Image) -> str:
     image.save(image_path, "JPEG")
     return image_path
 
-# Subir imágenes
 def upload(files: Optional[List[str]], chatbot: CHAT_HISTORY) -> CHAT_HISTORY:
     for file in files:
         image = Image.open(file).convert('RGB')
         image_preview = preprocess_image(image)
         if image_preview:
+            # Display a preview of the uploaded image
             gr.Image(image_preview).render()
         image_path = cache_pil_image(image)
         chatbot.append(((image_path,), None))
     return chatbot
 
-# Manejo del usuario
 def user(text_prompt: str, chatbot: CHAT_HISTORY):
     if text_prompt:
         chatbot.append((text_prompt, None))
     return "", chatbot
 
-# Manejo del bot con historial
 def bot(
     files: Optional[List[str]],
     model_choice: str,
-    system_instruction: str,
+    system_instruction: str,  # Añadido el parámetro para la instrucción del sistema
     chatbot: CHAT_HISTORY
 ):
     if not GOOGLE_API_KEY:
@@ -103,31 +67,38 @@ def bot(
     # Configurar la API con la clave
     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
+        temperature=0.7,  # Valor predeterminado
+        max_output_tokens=8192,  # Fijar el límite de tokens a 8,192
+        top_k=10,  # Valor predeterminado
+        top_p=0.9   # Valor predeterminado
     )
 
-    text_prompt = chatbot[-1][0] if chatbot and chatbot[-1][0] and isinstance(chatbot[-1][0], str) else ""
-    transformed_history = transform_history(chatbot)
-
+    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 []
+    
     # Crear el modelo con la instrucción del sistema
     model = genai.GenerativeModel(
         model_name=model_choice,
         generation_config=generation_config,
-        system_instruction=system_instruction
+        system_instruction=system_instruction  # Se pasa la instrucción del sistema
     )
 
-    # Generar la respuesta usando la función `response`
-    bot_reply = response(text_prompt, transformed_history, model)
-    chatbot[-1] = (text_prompt, bot_reply)
-    return chatbot
+    response = model.generate_content(text_prompt + image_prompt, stream=True, generation_config=generation_config)
+
+    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
 
-# Componentes de la interfaz
+# Componente para ingresar 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,
@@ -156,22 +127,22 @@ user_inputs = [
 bot_inputs = [
     upload_button_component,
     model_choice_component,
-    system_instruction_component,
+    system_instruction_component,  # Añadido el campo de instrucción del sistema
     chatbot_component
 ]
 
-# Interfaz de usuario
+# Definir la interfaz de usuario
 with gr.Blocks() as demo:
     gr.HTML(TITLE)
     gr.HTML(SUBTITLE)
     with gr.Column():
-        model_choice_component.render()
         chatbot_component.render()
         with gr.Row():
             text_prompt_component.render()
             upload_button_component.render()
             run_button_component.render()
-        system_instruction_component.render()
+        model_choice_component.render()
+        system_instruction_component.render()  # Mostrar el campo de la instrucción del sistema
 
     run_button_component.click(
         fn=user,