Update app.py

app.py

@@ -1,128 +1,132 @@
-TITLE = """<h1 align="center">Gemini Playground ✨</h1>"""
-SUBTITLE = """<h2 align="center">Play with Gemini Pro and Gemini Pro Vision</h2>"""
+Para procesar un archivo que puede ser una imagen, un PDF o un archivo de texto, es necesario modificar la función de subida para manejar varios tipos de archivos y verificar el MIME type automáticamente. A continuación, muestro cómo adaptar el código:
 
+### Código Adaptado con Funcionalidad para Procesar Diferentes Tipos de Archivos
+```python
 import os
 import time
-from typing import List, Tuple, Optional, Union
-
 import google.generativeai as genai
-import gradio as gr
-from dotenv import load_dotenv
-
-# Cargar las variables de entorno desde el archivo .env
-load_dotenv()
-
-# Obtener la clave de la API de las variables de entorno
-GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")
+from mimetypes import MimeTypes
 
-# 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.")
+# Configurar la API de Gemini
+genai.configure(api_key=os.environ["GEMINI_API_KEY"])
 
-# Configurar la API
-genai.configure(api_key=GOOGLE_API_KEY)
-
-# Constantes
-IMAGE_WIDTH = 512
-CHAT_HISTORY = List[Tuple[Optional[Union[Tuple[str], str]], Optional[str]]]
+def upload_and_process_file(path):
+    """
+    Sube y procesa un archivo para usarlo con el modelo de Gemini.
 
-def user(text_prompt: str, chatbot: CHAT_HISTORY):
+    - Detecta automáticamente el tipo MIME del archivo.
+    - Procesa imágenes, PDFs y archivos de texto.
     """
-    Maneja las entradas del usuario en el chatbot.
+    # Detectar el tipo MIME del archivo
+    mime = MimeTypes()
+    mime_type, _ = mime.guess_type(path)
+    
+    if not mime_type:
+        raise ValueError("No se pudo determinar el tipo MIME del archivo.")
+    
+    # Subir el archivo a Gemini
+    print(f"Subiendo el archivo '{path}' con MIME type '{mime_type}'...")
+    file = genai.upload_file(path, mime_type=mime_type)
+    print(f"Archivo subido: {file.display_name}, URI: {file.uri}")
+
+    # Esperar a que el archivo esté activo
+    wait_for_files_active([file])
+    return file
+
+def wait_for_files_active(files):
     """
-    if text_prompt:
-        chatbot.append((text_prompt, None))
-    return "", chatbot
-
-def bot(
-    model_choice: str,
-    system_instruction: Optional[str],
-    chatbot: CHAT_HISTORY
-):
+    Espera a que los archivos subidos a Gemini estén activos y listos para su uso.
     """
-    Maneja las respuestas del modelo generativo.
+    print("Esperando el procesamiento de los archivos...")
+    for file in files:
+        status = genai.get_file(file.name)
+        while status.state.name == "PROCESSING":
+            print(".", end="", flush=True)
+            time.sleep(5)  # Intervalo de espera más corto para mejorar la experiencia del usuario
+            status = genai.get_file(file.name)
+        
+        if status.state.name != "ACTIVE":
+            raise Exception(f"El archivo {file.name} no pudo procesarse correctamente.")
+    print("\nTodos los archivos están listos.")
+
+# Configuración del modelo generativo
+generation_config = {
+    "temperature": 1,
+    "top_p": 0.95,
+    "top_k": 40,
+    "max_output_tokens": 8192,
+    "response_mime_type": "text/plain",
+}
+
+model = genai.GenerativeModel(
+    model_name="gemini-1.5-flash",
+    generation_config=generation_config,
+)
+
+def start_chat_with_file(file, user_input):
     """
-    generation_config = genai.types.GenerationConfig(
-        temperature=0.7,
-        max_output_tokens=8192,
-        top_k=10,
-        top_p=0.9
+    Inicia una conversación con el modelo utilizando un archivo como entrada.
+    """
+    chat_session = model.start_chat(
+        history=[
+            {
+                "role": "user",
+                "parts": [file],
+            },
+        ]
     )
 
-    # Usar un valor predeterminado si system_instruction está vacío
-    if not system_instruction:
-        system_instruction = "You are a helpful assistant."
+    # Enviar mensaje al modelo
+    response = chat_session.send_message(user_input)
+    return response.text
 
-    # Obtener el prompt más reciente del usuario
-    text_prompt = [chatbot[-1][0]] if chatbot and chatbot[-1][0] else []
 
-    # Crear y configurar el modelo generativo
-    model = genai.GenerativeModel(
-        model_name=model_choice,
-        generation_config=generation_config,
-        system_instruction=system_instruction,
-    )
+# Ejemplo de uso
+if __name__ == "__main__":
+    # Ruta del archivo a subir
+    file_path = "ruta_al_archivo.pdf"  # Cambiar por la ruta del archivo
 
-    # Generar contenido usando streaming
-    response = model.generate_content(text_prompt, stream=True)
+    # Subir y procesar el archivo
+    try:
+        processed_file = upload_and_process_file(file_path)
+    except Exception as e:
+        print(f"Error al procesar el archivo: {e}")
+        exit(1)
 
-    # Preparar la respuesta para el chatbot
-    chatbot[-1] = (chatbot[-1][0], "")
-    for chunk in response:
-        chatbot[-1] = (chatbot[-1][0], chatbot[-1][1] + chunk.text)
-        yield chatbot
+    # Interactuar con el modelo usando el archivo procesado
+    user_input = "Por favor, analiza este documento y dame un resumen."
+    response = start_chat_with_file(processed_file, user_input)
 
-# Componentes de la interfaz de usuario
-system_instruction_component = gr.Textbox(
-    placeholder="Enter system instruction...",
-    label="System Instruction",
-    lines=2
-)
-chatbot_component = gr.Chatbot(label='Gemini', bubble_full_width=False, height=300)
-text_prompt_component = gr.Textbox(placeholder="Message...", show_label=False, autofocus=True)
-run_button_component = gr.Button(value="Run", variant="primary")
-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"
-)
+    # Mostrar la respuesta
+    print("Respuesta del modelo:")
+    print(response)
+```
 
-user_inputs = [text_prompt_component, chatbot_component]
-bot_inputs = [model_choice_component, system_instruction_component, chatbot_component]
-
-# Definir la interfaz de usuario
-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()
-        chatbot_component.render()
-        with gr.Row():
-            text_prompt_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):
-            system_instruction_component.render()
-
-    run_button_component.click(
-        fn=user,
-        inputs=user_inputs,
-        outputs=[text_prompt_component, chatbot_component],
-        queue=False
-    ).then(
-        fn=bot, inputs=bot_inputs, outputs=[chatbot_component],
-    )
+---
 
-    text_prompt_component.submit(
-        fn=user,
-        inputs=user_inputs,
-        outputs=[text_prompt_component, chatbot_component],
-        queue=False
-    ).then(
-        fn=bot, inputs=bot_inputs, outputs=[chatbot_component],
-    )
+### **Qué hace este código adaptado:**
+1. **Detección Automática del Tipo MIME**:
+   - Usa la librería `mimetypes` para identificar si el archivo es una imagen (`image/*`), PDF (`application/pdf`), o texto (`text/plain`).
+   - Esto elimina la necesidad de especificar manualmente el tipo MIME.
+
+2. **Subida de Archivos**:
+   - La función `upload_and_process_file` sube cualquier archivo compatible a Gemini y espera a que esté procesado y listo.
+
+3. **Espera Activa Mejorada**:
+   - Reduce el tiempo de espera a 5 segundos para mejorar la experiencia del usuario sin afectar el rendimiento.
+
+4. **Inicio de Chat**:
+   - Usa el archivo procesado como entrada inicial en la conversación con el modelo.
+
+5. **Respuesta Generada**:
+   - El modelo analiza el archivo y responde según la consulta del usuario.
+
+---
 
-# Lanzar la aplicación
-demo.queue(max_size=99).launch(debug=False, show_error=True)
+### **Ampliaciones Posibles**:
+- **Validación de Archivos**:
+  - Añadir comprobaciones para asegurarse de que solo se suben formatos soportados.
+- **Manejo de Errores**:
+  - Implementar mejores mensajes de error y reintentos para los archivos que fallan al procesarse.
+- **Interfaz Gráfica (opcional)**:
+  - Integrar este código en una aplicación de `Gradio` para permitir la carga de archivos directamente desde el navegador.