Update app.py

app.py

@@ -58,16 +58,16 @@ 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' y 'RESPUESTAS' (ignorando mayúsculas/minúsculas).
+    Busca las palabras 'Preguntas' y 'RESPUESTAS' ignorando espacios al inicio y mayúsculas.
     """
-    match_preg = re.search(r'(?i)preguntas', texto)
-    match_resp = re.search(r'(?i)respuestas', texto)
+    match_preg = re.search(r'(?im)^\s*preguntas', texto)
+    match_resp = re.search(r'(?im)^\s*respuestas', texto)
     
     if not match_preg or not match_resp:
         return (texto, "")
     
-    start_preg = match_preg.end()  # fin de la palabra 'Preguntas'
-    start_resp = match_resp.start()
+    start_preg = match_preg.end()  # donde termina "Preguntas"
+    start_resp = match_resp.start()  # donde empieza "RESPUESTAS"
     
     texto_preguntas = texto[start_preg:start_resp].strip()
     texto_respuestas = texto[match_resp.end():].strip()
@@ -75,25 +75,31 @@ def split_secciones(texto: str) -> (str, str):
 
 def parsear_enumeraciones(texto: str) -> dict:
     """
-    Dado un texto con enumeraciones del tipo '1. ...', '2. ...', etc.,
+    Dado un texto que contiene enumeraciones de preguntas (por ejemplo, "1. 1- RTA1" o "2- RTA2"),
     separa cada número y su contenido.
     Retorna un dict: {"Pregunta 1": "contenido", "Pregunta 2": "contenido", ...}.
+    Este patrón es flexible y tolera espacios al inicio y formatos creativos.
     """
-    bloques = re.split(r'(?=^\d+\.\s)', texto, flags=re.MULTILINE)
+    # El patrón usa lookahead para dividir cada bloque cuando se encuentre una línea que comience con un número,
+    # un punto o guión y opcionalmente otro número seguido de un punto o guión.
+    bloques = re.split(r'(?=^\s*\d+[\.\-]\s*(?:\d+[\.\-])?\s*)', texto, flags=re.MULTILINE)
     resultado = {}
     for bloque in bloques:
-        bloque_limpio = bloque.strip()
-        if not bloque_limpio:
+        bloque = bloque.strip()
+        if not bloque:
             continue
-        linea_principal = bloque_limpio.split("\n", 1)[0]
-        match_num = re.match(r'^(\d+)\.\s*(.*)', linea_principal)
-        if match_num:
-            numero = match_num.group(1)
-            if "\n" in bloque_limpio:
-                resto = bloque_limpio.split("\n", 1)[1].strip()
-            else:
-                resto = match_num.group(2)
-            resultado[f"Pregunta {numero}"] = resto.strip()
+        # El patrón extrae el primer número (que identificará la pregunta) y el contenido.
+        match = re.match(r'^\s*(\d+)[\.\-]\s*(?:\d+[\.\-])?\s*(.*)', bloque)
+        if match:
+            numero = match.group(1)
+            contenido = match.group(2)
+            # Si el bloque tiene múltiples líneas, se unen las líneas siguientes
+            lineas = bloque.split("\n")
+            if len(lineas) > 1:
+                contenido_completo = " ".join([linea.strip() for linea in lineas[1:]])
+                if contenido_completo:
+                    contenido += " " + contenido_completo
+            resultado[f"Pregunta {numero}"] = contenido.strip()
     return resultado
 
 # ------------
@@ -114,13 +120,11 @@ def comparar_preguntas_respuestas(dict_docente: dict, dict_alumno: dict) -> (str
           * Incorrecta: ratio < 0.5
     Devuelve:
       - Un string con la retroalimentación por pregunta.
-      - Una lista de diccionarios con el análisis por pregunta (para la conclusión).
-        Solo se incluyen las preguntas que fueron asignadas al alumno.
+      - Una lista de diccionarios con el análisis por pregunta (solo para las asignadas).
     """
     feedback = []
     analisis = []
     for pregunta, resp_correcta in dict_docente.items():
-        # Se “limpian” los textos para eliminar saltos de línea y espacios de más.
         correct_clean = " ".join(resp_correcta.split())
         resp_alumno_raw = dict_alumno.get(pregunta, "").strip()
         
@@ -130,7 +134,6 @@ def comparar_preguntas_respuestas(dict_docente: dict, dict_alumno: dict) -> (str
                 f"Respuesta del alumno: No fue asignada.\n"
                 f"Respuesta correcta: {correct_clean}\n"
             )
-            # Se agrega al análisis, pero marcando que no fue asignada.
             analisis.append({"pregunta": pregunta, "asignada": False})
         else:
             alumno_clean = " ".join(resp_alumno_raw.split())
@@ -161,12 +164,10 @@ def revisar_examen(json_cred, pdf_docente, pdf_alumno):
     Función generadora que:
       1. Configura credenciales.
       2. Extrae y parsea el contenido de los PDFs.
-      3. Compara las respuestas del alumno con las correctas.
-      4. Genera una retroalimentación detallada por pregunta.
-      5. Llama a un LLM para obtener un resumen final que incluya:
-           - Puntos fuertes (conceptos bien entendidos).
-           - Puntos a reforzar (respuestas incompletas o incorrectas).
-           - Recomendación general (solo considerando las preguntas asignadas).
+      3. Separa las secciones 'Preguntas' y 'RESPUESTAS'.
+      4. Parsea las enumeraciones de cada sección (permitiendo formatos creativos).
+      5. Compara las respuestas del alumno con las correctas.
+      6. Llama a un LLM para generar un resumen final con retroalimentación.
     """
     yield "Cargando credenciales..."
     try:
@@ -190,7 +191,6 @@ def revisar_examen(json_cred, pdf_docente, pdf_alumno):
         yield "Parseando enumeraciones (docente)..."
         dict_preg_doc = parsear_enumeraciones(preguntas_doc)
         dict_resp_doc = parsear_enumeraciones(respuestas_doc)
-        
         # Unir las respuestas del docente (correctas)
         dict_docente = {}
         for key in dict_preg_doc:
@@ -199,7 +199,6 @@ def revisar_examen(json_cred, pdf_docente, pdf_alumno):
         yield "Parseando enumeraciones (alumno)..."
         dict_preg_alum = parsear_enumeraciones(preguntas_alum)
         dict_resp_alum = parsear_enumeraciones(respuestas_alum)
-        
         # Unir las respuestas del alumno
         dict_alumno = {}
         for key in dict_preg_alum:
@@ -207,24 +206,19 @@ def revisar_examen(json_cred, pdf_docente, pdf_alumno):
         
         yield "Comparando preguntas y respuestas..."
         feedback_text, analisis = comparar_preguntas_respuestas(dict_docente, dict_alumno)
-        
         if len(feedback_text.strip()) < 5:
             yield "No se encontraron preguntas o respuestas válidas."
             return
         
-        # Generar resumen global utilizando el LLM
-        # Se filtran solo las preguntas asignadas (se omiten las que no fueron asignadas)
+        # Generar resumen global utilizando el LLM (solo para preguntas asignadas)
         analisis_asignadas = [a for a in analisis if a.get("asignada")]
         resumen_prompt = f"""
 A continuación se presenta el análisis por pregunta de un examen sobre la regulación del colesterol, considerando solo las preguntas asignadas al alumno:
-
 {analisis_asignadas}
-
 Con base en este análisis, genera un resumen del desempeño del alumno en el examen que incluya:
 - Puntos fuertes: conceptos que el alumno ha comprendido correctamente.
 - Puntos a reforzar: preguntas en las que la respuesta fue incompleta o incorrecta, indicando qué conceptos clave faltaron o se confundieron.
 - Una recomendación general sobre si el alumno demuestra comprender los fundamentos o si necesita repasar el tema.
-
 No incluyas en el análisis las preguntas que no fueron asignadas.
 """
         yield "Generando resumen final con LLM..."
@@ -240,10 +234,8 @@ No incluyas en el análisis las preguntas que no fueron asignadas.
             stream=False
         )
         resumen_final = summary_resp.text.strip()
-        
         final_result = f"{feedback_text}\n\n**Resumen del desempeño:**\n{resumen_final}"
         yield final_result
-        
     except Exception as e:
         yield f"Error al procesar: {str(e)}"
 
@@ -261,11 +253,10 @@ interface = gr.Interface(
     title="Revisión de Exámenes (Preguntas/Respuestas enumeradas)",
     description=(
         "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. "
-        "Se evalúa si el alumno comprende los conceptos fundamentales: si la respuesta está incompleta se indica qué falta, "
+        "El sistema separa las secciones 'Preguntas' y 'RESPUESTAS', parsea las enumeraciones (soportando formatos creativos) "
+        "y luego compara las respuestas. Se evalúa si el alumno comprende los conceptos fundamentales: si la respuesta está incompleta se indica qué falta, "
         "si es incorrecta se comenta por qué, y se omiten las preguntas no asignadas. Finalmente, se genera un resumen con recomendaciones."
     )
 )
 
 interface.launch(debug=True)
-