Update app.py

app.py

@@ -6,7 +6,6 @@ from PIL import Image
 import google.generativeai as genai
 import gradio as gr
 from dotenv import load_dotenv
-import base64
 
 # Cargar las variables de entorno desde el archivo .env
 load_dotenv()
@@ -30,64 +29,50 @@ model = genai.GenerativeModel(
     generation_config=generation_config,
 )
 
-# Inicializar la sesión de chat
-chat = model.start_chat(history=[])
-
-# Función para transformar una imagen en un blob compatible con Gemini
-def image_to_blob(image: Image.Image) -> dict:
-    """Convierte una imagen a un blob compatible con Gemini."""
-    buffered = io.BytesIO()
-    image.save(buffered, format="JPEG")
-    image_data = base64.b64encode(buffered.getvalue()).decode()
-    return {
-        "mime_type": "image/jpeg",
-        "data": image_data
-    }
-
-# Función para transformar el historial de Gradio al formato de Gemini
-def transform_history(history):
-    """Transforma el historial del formato de Gradio al formato que Gemini espera."""
-    new_history = []
-    for chat in history:
-        if chat[0]:  # Mensaje del usuario
-            new_history.append({"parts": [{"text": chat[0]}], "role": "user"})
-        if chat[1]:  # Respuesta del modelo
-            new_history.append({"parts": [{"text": chat[1]}], "role": "model"})
-    return new_history
+# Constantes para el manejo de imágenes
+IMAGE_CACHE_DIRECTORY = "/tmp"
+IMAGE_WIDTH = 512
+CHAT_HISTORY = List[Tuple[Optional[Union[Tuple[str], str]], Optional[str]]]
+
+# Función para preprocesar una imagen
+def preprocess_image(image: Image.Image) -> Optional[Image.Image]:
+    """Redimensiona una imagen manteniendo la relación de aspecto."""
+    if image:
+        image_height = int(image.height * IMAGE_WIDTH / image.width)
+        return image.resize((IMAGE_WIDTH, image_height))
+
+# Función para almacenar una imagen en caché
+def cache_pil_image(image: Image.Image) -> str:
+    """Guarda la imagen como archivo JPEG en un directorio temporal."""
+    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
 
 # Función principal para manejar las respuestas del chat
 def response(message, history):
     """Maneja la interacción multimodal y envía texto e imágenes al modelo."""
-    global chat
-
-    # Transformar el historial al formato esperado por Gemini
-    chat.history = transform_history(history)
-
-    # Obtener el texto del mensaje y las imágenes cargadas
     text_prompt = message["text"]
     files = message["files"]
-
+    
     # Procesar imágenes cargadas
     image_prompts = []
     if files:
         for file in files:
             image = Image.open(file).convert('RGB')
-            image_blob = image_to_blob(image)
-            image_prompts.append(image_blob)
-
-    # Crear las partes para el modelo
-    parts = [{"text": text_prompt}]
-    for img_blob in image_prompts:
-        parts.append({"inline_data": img_blob})
-
-    # Enviar el mensaje al modelo
-    response = chat.send_message({"parts": parts})
-    response.resolve()
-
-    # Generar respuesta carácter por carácter para una experiencia más fluida
-    for i in range(len(response.text)):
-        time.sleep(0.01)
-        yield response.text[: i + 1]
+            image_preview = preprocess_image(image)
+            if image_preview:
+                cache_pil_image(image)
+                image_prompts.append(image_preview)  # Incluir en la lista de prompts
+
+    # Concatenar texto e imágenes para el modelo
+    prompts = [text_prompt] + image_prompts
+    response = model.generate_content(prompts, stream=True, generation_config=generation_config)
+
+    # Generar respuesta paso a paso
+    for chunk in response:
+        yield chunk.text
 
 # Crear la interfaz de usuario
 demo = gr.ChatInterface(