Update app.py

app.py

@@ -4,6 +4,7 @@ import os
 import re
 import vertexai
 from vertexai.generative_models import GenerativeModel, Part, SafetySetting
+from difflib import SequenceMatcher  # Para comparar similitud
 
 # --------------------
 # CONFIGURACIÓN GLOBAL
@@ -57,81 +58,82 @@ def extraer_texto(pdf_path: str) -> str:
 def split_secciones(texto: str) -> (str, str):
     """
     Separa el texto en dos partes: la sección 'Preguntas' y la sección 'RESPUESTAS'.
-    - Busca la palabra 'Preguntas' (o 'PREGUNTAS') y 'RESPUESTAS' (o 'RESPUESTAS').
-    - Devuelve (texto_preguntas, texto_respuestas).
-      Si no las encuentra, devuelvo (texto, "") o similar.
+    Busca la palabra 'Preguntas' y 'RESPUESTAS' (ignorando mayúsculas/minúsculas).
     """
-    # Usamos re.IGNORECASE para ignorar mayúsculas/minúsculas
-    # Buscamos la posición de 'Preguntas' y 'RESPUESTAS' en el string
     match_preg = re.search(r'(?i)preguntas', texto)
     match_resp = re.search(r'(?i)respuestas', texto)
     
     if not match_preg or not match_resp:
-        # Si no encontramos ambas, devolvemos algo por defecto
         return (texto, "")
-
-    start_preg = match_preg.end()  # donde termina la palabra 'Preguntas'
+    
+    start_preg = match_preg.end()  # fin de la palabra 'Preguntas'
     start_resp = match_resp.start()
     
-    # Sección de 'Preguntas' = texto entre 'Preguntas' y 'RESPUESTAS'
-    # Sección de 'RESPUESTAS' = texto desde 'RESPUESTAS' hasta el final
     texto_preguntas = texto[start_preg:start_resp].strip()
     texto_respuestas = texto[match_resp.end():].strip()
     return (texto_preguntas, texto_respuestas)
 
 def parsear_enumeraciones(texto: str) -> dict:
     """
-    Dado un texto que contiene enumeraciones del tipo '1. ...', '2. ...', etc.,
+    Dado un texto con enumeraciones del tipo '1. ...', '2. ...', etc.,
     separa cada número y su contenido.
     Retorna un dict: {"Pregunta 1": "contenido", "Pregunta 2": "contenido", ...}.
     """
-    # Dividimos en "bloques" usando lookahead para no perder el delimitador.
-    # Ej:   1. ... \n 2. ... \n
-    # Regex: busca línea que inicie con dígitos y un punto (ej: 1.)
     bloques = re.split(r'(?=^\d+\.\s)', texto, flags=re.MULTILINE)
-
     resultado = {}
     for bloque in bloques:
         bloque_limpio = bloque.strip()
         if not bloque_limpio:
             continue
-        # Tomamos la primera línea para ver "1. " o "2. "
         linea_principal = bloque_limpio.split("\n", 1)[0]
-        # Extraer el número
         match_num = re.match(r'^(\d+)\.\s*(.*)', linea_principal)
         if match_num:
             numero = match_num.group(1)
-            # El resto del contenido es el bloque completo sin la línea principal
-            # o bien group(2) + la parte posterior
-            resto = ""
             if "\n" in bloque_limpio:
                 resto = bloque_limpio.split("\n", 1)[1].strip()
             else:
-                # No hay más líneas, sólo la principal
                 resto = match_num.group(2)
-
             resultado[f"Pregunta {numero}"] = resto.strip()
     return resultado
 
 # ------------
 # COMPARACIÓN
 # ------------
+def similar_textos(texto1: str, texto2: str) -> float:
+    """Calcula la similitud entre dos textos (valor entre 0 y 1)."""
+    return SequenceMatcher(None, texto1, texto2).ratio()
+
 def comparar_preguntas_respuestas(dict_docente: dict, dict_alumno: dict) -> str:
     """
     Compara dict_docente vs dict_alumno y retorna retroalimentación.
-    - Si la 'Pregunta X' no está en dict_alumno, => 'No fue asignada'.
-    - Si sí está => mostramos la respuesta del alumno y la supuesta 'correcta'.
+    - Si la 'Pregunta X' no está en dict_alumno, se recomienda revisar el tema.
+    - Si está, se compara la respuesta del alumno con la correcta.
+    Se eliminan los saltos de línea en la respuesta del 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")
+        if resp_alumno is None or resp_alumno.strip() == "":
+            retroalimentacion.append(
+                f"**{pregunta}**\n"
+                f"Respuesta del alumno: No fue asignada.\n"
+                f"Respuesta correcta: {' '.join(resp_correcta.split())}\n"
+                f"Recomendación: Revisar el tema correspondiente.\n"
+            )
         else:
+            # Eliminar saltos de línea y espacios extra
+            resp_alumno_clean = " ".join(resp_alumno.split())
+            resp_correcta_clean = " ".join(resp_correcta.split())
+            ratio = similar_textos(resp_alumno_clean.lower(), resp_correcta_clean.lower())
+            if ratio >= 0.8:
+                feedback_text = "La respuesta es correcta."
+            else:
+                feedback_text = "La respuesta no coincide completamente. Se recomienda revisar la explicación y reforzar el concepto."
             retroalimentacion.append(
                 f"**{pregunta}**\n"
-                f"Respuesta del alumno: {resp_alumno}\n"
-                f"Respuesta correcta: {resp_correcta}\n"
+                f"Respuesta del alumno: {resp_alumno_clean}\n"
+                f"Respuesta correcta: {resp_correcta_clean}\n"
+                f"{feedback_text}\n"
             )
     return "\n".join(retroalimentacion)
 
@@ -141,12 +143,13 @@ def comparar_preguntas_respuestas(dict_docente: dict, dict_alumno: dict) -> str:
 def revisar_examen(json_cred, pdf_docente, pdf_alumno):
     """
     Función generadora que muestra progreso en Gradio con yield.
-    1. Configuramos credenciales
-    2. Extraemos texto de PDFs
-    3. Separamos secciones 'Preguntas' y 'RESPUESTAS' en docente y alumno
-    4. Parseamos enumeraciones
-    5. Comparamos
-    6. Llamamos a LLM para un resumen final
+    Realiza los siguientes pasos:
+      1. Configura credenciales.
+      2. Extrae texto de los PDFs.
+      3. Separa secciones 'Preguntas' y 'RESPUESTAS'.
+      4. Parsea las enumeraciones.
+      5. Compara las respuestas y genera retroalimentación con recomendaciones.
+      6. Llama a un LLM para generar un resumen final.
     """
     yield "Cargando credenciales..."
     try:
@@ -171,27 +174,23 @@ def revisar_examen(json_cred, pdf_docente, pdf_alumno):
         dict_preg_doc = parsear_enumeraciones(preguntas_doc)
         dict_resp_doc = parsear_enumeraciones(respuestas_doc)
 
-        # Unimos dict_preg_doc y dict_resp_doc para crear un dict final
-        # Ej: "Pregunta 1" en dict_preg_doc con "Pregunta 1" en dict_resp_doc
-        # => dict_docente["Pregunta 1"] = "Respuesta 1..."
+        # Unir preguntas y respuestas del docente
         dict_docente = {}
-        for key_preg, texto_preg in dict_preg_doc.items():
-            # Revisar si en dict_resp_doc hay el mismo 'Pregunta X'
+        for key_preg in dict_preg_doc:
             resp_doc = dict_resp_doc.get(key_preg, "")
-            # Unimos la respuesta en un sólo string
             dict_docente[key_preg] = resp_doc
 
         yield "Parseando enumeraciones (alumno)..."
         dict_preg_alum = parsear_enumeraciones(preguntas_alum)
         dict_resp_alum = parsear_enumeraciones(respuestas_alum)
 
-        # Unir en un dict final de alumno
+        # Unir preguntas y respuestas del alumno
         dict_alumno = {}
-        for key_preg, texto_preg in dict_preg_alum.items():
+        for key_preg in dict_preg_alum:
             resp_alum = dict_resp_alum.get(key_preg, "")
             dict_alumno[key_preg] = resp_alum
 
-        yield "Comparando preguntas/respuestas..."
+        yield "Comparando preguntas y respuestas..."
         feedback = comparar_preguntas_respuestas(dict_docente, dict_alumno)
 
         if len(feedback.strip()) < 5:
@@ -205,11 +204,10 @@ def revisar_examen(json_cred, pdf_docente, pdf_alumno):
             system_instruction=["Eres un profesor experto de bioquímica. No inventes preguntas."]
         )
         summary_prompt = f"""
-        Comparación de preguntas y respuestas:
-        {feedback}
-        Por favor, genera un breve resumen del desempeño del alumno 
-        sin inventar preguntas adicionales.
-        """
+Comparación de preguntas y respuestas:
+{feedback}
+Por favor, genera un breve resumen del desempeño del alumno, indicando si entiende los conceptos y recomendando reforzar los puntos necesarios.
+"""
         summary_part = Part.from_text(summary_prompt)
         summary_resp = model.generate_content(
             [summary_part],
@@ -227,8 +225,6 @@ def revisar_examen(json_cred, pdf_docente, pdf_alumno):
 # -----------------
 # INTERFAZ DE GRADIO
 # -----------------
-import gradio as gr
-
 interface = gr.Interface(
     fn=revisar_examen,
     inputs=[
@@ -236,12 +232,12 @@ interface = gr.Interface(
         gr.File(label="PDF del Docente"),
         gr.File(label="PDF del Alumno")
     ],
-    outputs="text",  # so we can see partial yields
+    outputs="text",
     title="Revisión de Exámenes (Preguntas/Respuestas enumeradas)",
     description=(
-        "Sube credenciales, el PDF del docente y del alumno. "
-        "Se busca la palabra 'Preguntas' y 'RESPUESTAS', parseamos enumeraciones (1., 2., etc.), "
-        "luego comparamos y finalmente pedimos un resumen al LLM."
+        "Sube las credenciales, el PDF del docente (con las preguntas y respuestas correctas) y el PDF del alumno. "
+        "El sistema separa las secciones 'Preguntas' y 'RESPUESTAS', parsea las enumeraciones y luego compara las respuestas. "
+        "Finalmente, se genera un resumen con recomendaciones para reforzar los conceptos según el desempeño del alumno."
     )
 )