Update app.py

app.py

@@ -1,27 +1,16 @@
 import gradio as gr
 import PyPDF2
 import os
+import json
 import vertexai
 from vertexai.generative_models import GenerativeModel, Part, SafetySetting
-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
+
+# Configuración global
 generation_config = {
-    "max_output_tokens": 8192,
+    "max_output_tokens": 4096,
     "temperature": 0,
-    "top_p": 0.75,
+    "top_p": 0.8,
 }
-
 safety_settings = [
     SafetySetting(
         category=SafetySetting.HarmCategory.HARM_CATEGORY_HATE_SPEECH,
@@ -45,7 +34,6 @@ def configurar_credenciales(json_path: str):
     os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = json_path
 
 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)
@@ -53,101 +41,121 @@ def extraer_texto(pdf_path: str) -> str:
             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 parsear_con_llm(texto_pdf: str, model: GenerativeModel) -> dict:
+    """
+    Usa el LLM para extraer preguntas y respuestas.
+    Devuelve un dict {"Pregunta X": "Respuesta X", ...}.
+    """
+    # Instrucciones para parsear:
+    # - Buscar variaciones de "Pregunta" y "Respuesta" (mayúsculas, minúsculas, plural...)
+    # - Devolver un JSON limpio, sin texto extra.
+    prompt = f"""
+    Eres un parser de texto. 
+    A continuación tienes el contenido de un PDF con un examen (o respuestas).
+    Debes extraer todas las preguntas y sus respuestas. 
+    Considera que las palabras podrían estar en mayúsculas, minúsculas o plural 
+    (por ejemplo 'Pregunta', 'PREGUNTA', 'Preguntas', 'RESPUESTA', 'RESPUESTAS', etc.).
+    Devuélvelas en formato JSON puro, sin explicación adicional. 
+    Usa este formato de salida:
+
+    {{
+      "Pregunta 1": "Texto de la respuesta",
+      "Pregunta 2": "Texto de la respuesta",
+      ...
+    }}
+
+    Si hay preguntas sin respuesta, pon la respuesta como cadena vacía.
+    Si no hay ninguna pregunta, devuelve un JSON vacío: {{}}
+
+    Texto PDF:
+    {texto_pdf}
+    """
+    part_text = Part(mime_type="text/plain", text=prompt)
+    response = model.generate_content(
+        [part_text],
+        generation_config=generation_config,
+        safety_settings=safety_settings,
+        stream=False
+    )
+    try:
+        data = json.loads(response.text.strip())
+        if isinstance(data, dict):
+            return data
+        else:
+            return {}
+    except:
+        # Si no se pudo parsear como JSON, devolvemos dict vacío
+        return {}
+
+def comparar_preguntas_respuestas(
+    dict_docente: dict, dict_alumno: dict
+) -> str:
+    """
+    Recorre las preguntas del dict_docente y 
+    compara con las respuestas del dict_alumno.
+    """
+    retroalimentacion = []
+    for pregunta, resp_correcta in dict_docente.items():
+        resp_alumno = dict_alumno.get(pregunta, None)
+        if resp_alumno is None:
+            retroalimentacion.append(
+                f"**{pregunta}**\nNo fue asignada al alumno.\n"
+            )
+        else:
+            retroalimentacion.append(
+                f"**{pregunta}**\n"
+                f"Respuesta del alumno: {resp_alumno}\n"
+                f"Respuesta correcta: {resp_correcta}\n"
+            )
+    return "\n".join(retroalimentacion)
 
 def revisar_examen(json_cred, pdf_docente, pdf_alumno):
     try:
-        # Configurar credenciales
+        # 1. Configurar credenciales
         configurar_credenciales(json_cred.name)
 
-        # Inicializar Vertex AI
+        # 2. Inicializar Vertex AI
         vertexai.init(project="deploygpt", location="us-central1")
 
-        # 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,
-        )
-
-        # 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.
-"""
-
-        model = GenerativeModel(
-            "gemini-1.5-pro-001",
-            system_instruction=[textsi_1]
-        )
-
-        # Llamada al modelo con las partes.
-        response = model.generate_content(
-            [part_filtrado],
+        # 3. Extraer texto de PDFs
+        texto_docente = extraer_texto(pdf_docente.name)
+        texto_alumno = extraer_texto(pdf_alumno.name)
+
+        # 4. Parsear con LLM para obtener dict de preguntas y respuestas
+        model = GenerativeModel("gemini-1.5-pro-001", system_instruction=["Eres un parser estricto."])
+        dict_docente = parsear_con_llm(texto_docente, model)
+        dict_alumno = parsear_con_llm(texto_alumno, model)
+
+        # 5. Comparar y generar retroalimentación
+        feedback = comparar_preguntas_respuestas(dict_docente, dict_alumno)
+
+        # 6. Generar un summary final con LLM (opcional)
+        # Queda a tu criterio si lo deseas:
+        if len(feedback.strip()) < 5:
+            return "No se encontraron preguntas/ respuestas válidas."
+        
+        # Llamada final al modelo para un summary:
+        summary_prompt = f"""
+        Eres un profesor experto. Te muestro la comparación de preguntas y respuestas:
+        {feedback}
+        Por favor, genera un breve resumen del desempeño del alumno 
+        sin inventar preguntas adicionales.
+        """
+        summary_part = Part(mime_type="text/plain", text=summary_prompt)
+        summary_resp = model.generate_content(
+            [summary_part],
             generation_config=generation_config,
             safety_settings=safety_settings,
-            stream=False,
+            stream=False
         )
+        summary_text = summary_resp.text.strip()
 
-        return response.text
+        return f"{feedback}\n\n**Resumen**\n{summary_text}"
 
     except Exception as e:
         return f"Error al procesar: {str(e)}"
 
+
 # Interfaz Gradio
 interface = gr.Interface(
     fn=revisar_examen,
@@ -156,9 +164,9 @@ interface = gr.Interface(
         gr.File(label="PDF Docente"),
         gr.File(label="PDF Alumno")
     ],
-    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."
+    outputs=gr.Markdown(),
+    title="Revisión de Exámenes con LLM (Permisivo)",
+    description="Sube credenciales, el PDF del docente y del alumno; se emplea un LLM para encontrar 'Pregunta/Respuesta' aun con variaciones."
 )
 
 interface.launch(debug=True)