Update app.py

app.py

@@ -42,30 +42,32 @@ def extraer_texto(pdf_path: str) -> str:
             texto_total += page.extract_text() or ""
     return texto_total
 
-def parsear_con_llm_con_enumeraciones(texto_pdf: str, model: GenerativeModel) -> dict:
+def parsear_con_llm(texto_pdf: str, model: GenerativeModel) -> dict:
     """
-    Usa el LLM para extraer las 'Preguntas' y sus 'Respuestas'.
-    Reconoce enumeraciones en 'Preguntas' (ej. '1.' o '1)') y en 'RESPUESTAS'.
-    Devuelve JSON con la forma:
-    {
-      "Pregunta 1": "Texto de la respuesta",
-      "Pregunta 2": "Texto de la respuesta",
-      ...
-    }
+    Prompt más flexible:
+    - Reconoce enumeraciones en secciones 'Preguntas' y 'RESPUESTAS', p. ej. '1.', '2)', '3-'.
+    - Permite que las preguntas tengan texto como "Teniendo en cuenta que..." sin la palabra "Pregunta".
+    - Devuelve un JSON que asocia la pregunta X con la respuesta X.
     """
     prompt = f"""
-Eres un parser de texto que recibe el contenido de un PDF con dos secciones:
-'Preguntas' y 'RESPUESTAS', cada una enumerada como '1.', '2)', etc.
-Tu tarea es emparejar cada pregunta con su respuesta correspondiente, basándote
-en el número que las identifica (1, 2, 3, ...).
-Devuelve un JSON con la estructura:
+Eres un parser de texto que recibe el contenido de un PDF con:
+- Una sección de \"Preguntas\" enumeradas (1., 2., 3..., etc.).
+- Una sección de \"RESPUESTAS\" enumeradas de la misma forma.
+
+Para cada número (1, 2, 3, 4, 5, 6...), empareja la pregunta con la respuesta. 
+Devuélvelo en un JSON con el siguiente formato:
+
 {{
-  "Pregunta 1": "texto de la respuesta",
-  "Pregunta 2": "texto de la respuesta",
+  "Pregunta 1": "texto de la respuesta 1",
+  "Pregunta 2": "texto de la respuesta 2",
   ...
 }}
-Si no hay correspondencia entre pregunta y respuesta, la dejas vacía.
-Ejemplo de JSON vacío: {{}}
+
+Reglas:
+1. Si una pregunta dice \"1. Teniendo en cuenta...\", eso es \"Pregunta 1\".
+2. Si en la sección RESPUESTAS dice \"1. Metabolismo...\", esa es la Respuesta 1.
+3. Si no hay correspondencia entre pregunta y respuesta, deja la respuesta como cadena vacía.
+4. Si no hay nada, devuelve un JSON vacío: {{}}.
 
 Texto PDF:
 {texto_pdf}
@@ -79,6 +81,8 @@ Devuelve solo el JSON, sin explicaciones adicionales.
         safety_settings=safety_settings,
         stream=False
     )
+
+    # Intentamos parsear el contenido como JSON
     try:
         data = json.loads(response.text.strip())
         if isinstance(data, dict):
@@ -104,46 +108,36 @@ def comparar_preguntas_respuestas(dict_docente: dict, dict_alumno: dict) -> str:
     return "\n".join(retroalimentacion)
 
 def revisar_examen(json_cred, pdf_docente, pdf_alumno):
-    """
-    Función convertida en generador para mostrar 'progreso' en Gradio:
-    en lugar de return final, se hace yield en varios pasos.
-    """
-    # Paso 1: Configurar credenciales
+    """Función generadora que muestra progreso en Gradio con yield."""
     yield "Cargando credenciales..."
     try:
         configurar_credenciales(json_cred.name)
-
-        # Paso 2: Inicializar Vertex AI
         yield "Inicializando Vertex AI..."
         vertexai.init(project="deploygpt", location="us-central1")
 
-        # Paso 3: Leer texto PDF
         yield "Extrayendo texto del PDF del docente..."
         texto_docente = extraer_texto(pdf_docente.name)
 
         yield "Extrayendo texto del PDF del alumno..."
         texto_alumno = extraer_texto(pdf_alumno.name)
 
-        # Paso 4: Invocar modelo
-        yield "Parseando preguntas y respuestas (Docente)..."
+        yield "Parseando preguntas/respuestas del docente..."
         model = GenerativeModel(
             "gemini-1.5-pro-001",
             system_instruction=["Eres un parser estricto."]
         )
-        dict_docente = parsear_con_llm_con_enumeraciones(texto_docente, model)
+        dict_docente = parsear_con_llm(texto_docente, model)
 
-        yield "Parseando preguntas y respuestas (Alumno)..."
-        dict_alumno = parsear_con_llm_con_enumeraciones(texto_alumno, model)
+        yield "Parseando preguntas/respuestas del alumno..."
+        dict_alumno = parsear_con_llm(texto_alumno, model)
 
-        # Paso 5: Comparar
-        yield "Comparando respuestas..."
+        yield "Comparando..."
         feedback = comparar_preguntas_respuestas(dict_docente, dict_alumno)
 
         if len(feedback.strip()) < 5:
             yield "No se encontraron preguntas o respuestas válidas."
-            return  # terminamos la función
+            return
 
-        # Paso 6: Resumen final
         yield "Generando resumen final..."
         summary_prompt = f"""
         Eres un profesor experto de bioquímica. Te muestro la comparación de preguntas y respuestas:
@@ -158,14 +152,15 @@ def revisar_examen(json_cred, pdf_docente, pdf_alumno):
             safety_settings=safety_settings,
             stream=False
         )
-        final_result = f"{feedback}\n\n**Resumen**\n{summary_resp.text.strip()}"
 
+        final_result = f"{feedback}\n\n**Resumen**\n{summary_resp.text.strip()}"
         yield final_result
 
     except Exception as e:
         yield f"Error al procesar: {str(e)}"
 
-# Interfaz Gradio
+import gradio as gr
+
 interface = gr.Interface(
     fn=revisar_examen,
     inputs=[
@@ -173,13 +168,12 @@ interface = gr.Interface(
         gr.File(label="PDF del Docente"),
         gr.File(label="PDF Alumno")
     ],
-    # Cuando la función es un generador, definimos outputs="text" (o gr.Textbox()).
     outputs="text",
-    title="Revisión de Exámenes con Enumeraciones (Progreso)",
+    title="Revisión de Exámenes (Preguntas enumeradas + RESPUESTAS enumeradas)",
     description=(
-        "Sube tus credenciales, el PDF del docente y del alumno. El LLM "
-        "detectará enumeraciones (1., 2), etc.) en 'Preguntas' y 'RESPUESTAS' "
-        "y mostrará progreso a medida que avanza."
+        "Sube tus credenciales, el PDF del docente y el PDF del alumno. El LLM "
+        "buscará enumeraciones (1., 2., 3., etc.) en PREGUNTAS y RESPUESTAS y "
+        "mostrará el avance paso a paso."
     )
 )