Update app.py

app.py

@@ -1,8 +1,19 @@
-import gradio as gr
-import base64
+mport gradio as gr
+import PyPDF2
+import os
 import vertexai
 from vertexai.generative_models import GenerativeModel, Part, SafetySetting
-import os
+import base64
+
+"""
+Este código se encarga de:
+1. Leer un archivo de credenciales JSON para configurar Google Cloud.
+2. Inicializar Vertex AI en la región us-central1.
+3. Extraer preguntas y respuestas de dos PDFs: uno del docente y otro del alumno.
+4. Filtrar únicamente las preguntas realmente respondidas por el alumno.
+5. Enviar ese contenido filtrado al modelo generativo (Gemini 1.5), con instrucciones para que
+   NO mencione preguntas no respondidas.
+"""
 
 # Configuración del modelo y parámetros globales
 generation_config = {
@@ -30,86 +41,124 @@ safety_settings = [
     ),
 ]
 
-def configurar_credenciales(json_path):
-    """Configura las credenciales de Google Cloud usando un archivo JSON."""
+def configurar_credenciales(json_path: str):
     os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = json_path
 
-def revisar_examen(json_path, pdf_docente, pdf_alumno):
-    """Función principal para comparar los PDFs del docente y del alumno."""
+def extraer_texto(pdf_path: str) -> str:
+    """Extraer texto de todas las páginas de un PDF."""
+    texto_total = ""
+    with open(pdf_path, "rb") as f:
+        lector = PyPDF2.PdfReader(f)
+        for page in lector.pages:
+            texto_total += page.extract_text() or ""
+    return texto_total
+
+def parsear_preguntas_respuestas(texto: str) -> dict:
+    """Dado un texto con formato, retorna un dict {pregunta: respuesta}."""
+    # Buscamos líneas que inicien con "Pregunta" y "Respuesta"
+    lineas = texto.split("\n")
+    resultado = {}
+    pregunta_actual = None
+
+    for linea in lineas:
+        linea_str = linea.strip()
+        if linea_str.lower().startswith("pregunta"):
+            pregunta_actual = linea_str
+            resultado[pregunta_actual] = ""
+        elif linea_str.lower().startswith("respuesta") and pregunta_actual:
+            # No mezclamos en la misma línea "Pregunta X:"
+            # sino que esperamos "Pregunta X" en una línea y "Respuesta X" en la siguiente
+            # si el formateo es distinto, ajusta aquí.
+            # Tomamos lo que está después de ':'
+            partes = linea_str.split(":", 1)
+            if len(partes) > 1:
+                respuesta = partes[1].strip()
+                resultado[pregunta_actual] = respuesta
+    return resultado
+
+def revisar_examen(json_cred, pdf_docente, pdf_alumno):
     try:
-        # Configurar las credenciales
-        configurar_credenciales(json_path)
+        # Configurar credenciales
+        configurar_credenciales(json_cred.name)
 
         # Inicializar Vertex AI
         vertexai.init(project="deploygpt", location="us-central1")
 
-        # Leer los datos de los PDFs desde la ruta proporcionada por Gradio
-        with open(pdf_docente.name, "rb") as docente_file:
-            docente_data = docente_file.read()
-        
-        with open(pdf_alumno.name, "rb") as alumno_file:
-            alumno_data = alumno_file.read()
-
-        # Codificar los datos de los PDFs a base64
-        document1 = Part.from_data(
-            mime_type="application/pdf",
-            data=base64.b64encode(docente_data).decode("utf-8"),
+        # Extraer texto de ambos PDFs
+        docente_texto = extraer_texto(pdf_docente.name)
+        alumno_texto = extraer_texto(pdf_alumno.name)
+
+        # Parsear preguntas y respuestas
+        preguntas_docente = parsear_preguntas_respuestas(docente_texto)
+        respuestas_alumno = parsear_preguntas_respuestas(alumno_texto)
+
+        # Filtrar solo preguntas respondidas
+        preguntas_filtradas = {}
+        for pregunta_doc, resp_doc in preguntas_docente.items():
+            if pregunta_doc in respuestas_alumno:
+                # El alumno respondió esta pregunta
+                preguntas_filtradas[pregunta_doc] = {
+                    "respuesta_doc": resp_doc,
+                    "respuesta_alumno": respuestas_alumno[pregunta_doc]
+                }
+
+        if not preguntas_filtradas:
+            return "El alumno no respondió ninguna de las preguntas del docente."
+
+        # Construir un texto que contenga únicamente las preguntas respondidas
+        # e instrucciones claras para no alucinar preguntas.
+        # Vamos a pasarlo en 1 solo Part, para forzar a que la LLM no confunda.
+        contenido_final = """Instrucciones: Solo hay estas preguntas respondidas por el alumno.
+No menciones preguntas que no estén en esta lista. Para cada pregunta, analiza la respuesta.
+Al final, da un resumen.
+"""
+        for i, (p, data) in enumerate(preguntas_filtradas.items(), 1):
+            contenido_final += f"\nPregunta {i}: {p}\n" \
+                             f"Respuesta del alumno: {data['respuesta_alumno']}\n" \
+                             f"Respuesta correcta (docente): {data['respuesta_doc']}\n"
+
+        # Creamos un Part con el contenido filtrado
+        part_filtrado = Part(
+            mime_type="text/plain",
+            text=contenido_final,
         )
 
-        document2 = Part.from_data(
-            mime_type="application/pdf",
-            data=base64.b64encode(alumno_data).decode("utf-8"),
-        )
+        # System instruction, for clarity
+        textsi_1 = """Actúa como un asistente de docente experto en Bioquímica.
+No menciones preguntas que el alumno no respondió.
+Analiza únicamente las preguntas provistas en el texto.
+Calcula un porcentaje de precisión basado en las respuestas incluidas.
+"""
 
-        # Configuración del texto de instrucciones
-        text1 = """Información del examen
-        Materia: bioquimica nutricion normal
-        Grado/Nivel: universidad
-        Tema: Metabolismo de lipidos
-        Formato del examen: \\\"Preguntas de desarrollo\\\"
-        Instrucciones para el asistente
-        Adjunta los archivos PDF:integracion
-        PDF del alumno: alumno
-        Solicita la revisión: \\\"Por favor, compara las respuestas del alumno en el PDF adjunto con las preguntas y respuestas del PDF del docente. Evalúa cada respuesta como 'Correcta', 'Incorrecta', 'Incompleta' o 'Vacía'. Considera que el alumno solo respondió a un subconjunto de las preguntas del examen. Para cada pregunta, indica si fue 'Asignada' o 'No asignada' al alumno. Proporciona retroalimentación detallada para cada respuesta de las preguntas asignadas, incluyendo la explicación de errores, la respuesta correcta (del PDF del docente) y sugerencias de temas para reforzar. Al final, ofrece una retroalimentación general sobre el desempeño del alumno y calcula el porcentaje de precisión, basándote solo en las preguntas que le fueron asignadas.\\\""""
-
-        textsi_1 = """Rol: Actúa como un asistente de docente experto en la materia del examen de Bioquimica.
-        Objetivo: Tu tarea principal es analizar las respuestas del alumno a las preguntas del examen, comparándolas con la clave de respuestas y criterios de evaluación proporcionados en el PDF del docente. Debes identificar las respuestas correctas, incorrectas, incompletas y vacías, tomando en cuenta que el alumno pudo haber recibido un subconjunto aleatorio de las preguntas del examen. Proporciona retroalimentación detallada sobre los errores, áreas de mejora y temas que el alumno necesita reforzar. Además, debes calcular y mostrar el porcentaje de precisión del alumno en el examen, considerando solo las preguntas que le fueron asignadas."""
-
-        # Configurar el modelo
         model = GenerativeModel(
-            "gemini-1.5-pro-001",  # Cambiar a Gemini-2
+            "gemini-1.5-pro-001",
             system_instruction=[textsi_1]
         )
 
-        # Generar la revisión
+        # Llamada al modelo con las partes.
         response = model.generate_content(
-            [document1, document2, text1],
+            [part_filtrado],
             generation_config=generation_config,
             safety_settings=safety_settings,
             stream=False,
         )
 
-        # Acceder al texto de la respuesta
-        feedback = response.text
-
-        return feedback
+        return response.text
 
     except Exception as e:
         return f"Error al procesar: {str(e)}"
 
-# Crear la interfaz con Gradio
+# Interfaz Gradio
 interface = gr.Interface(
     fn=revisar_examen,
     inputs=[
-        gr.File(label="Archivo de Credenciales JSON"),
-        gr.File(label="PDF del Docente (Preguntas y Respuestas)"),
-        gr.File(label="PDF del Alumno (Respuestas)")
+        gr.File(label="Credenciales JSON"),
+        gr.File(label="PDF Docente"),
+        gr.File(label="PDF Alumno")
     ],
-    outputs=gr.Textbox(label="Retroalimentación del Examen"),
-    title="Revisión Automática de Exámenes",
-    description="Sube el archivo de credenciales JSON de Google Cloud, el PDF del docente y el PDF del alumno para recibir una evaluación detallada."
+    outputs=gr.Textbox(label="Resultado"),
+    title="Revisión de Exámenes",
+    description="Sube tus credenciales, el PDF del docente y el del alumno para revisar las respuestas sin alucinaciones."
 )
 
-# Lanzar la interfaz
 interface.launch(debug=True)
-