Update app.py

app.py

@@ -3,7 +3,7 @@ import gradio as gr
 import requests
 import inspect
 import pandas as pd
-from agent import AmbiguityClassifier
+from text_analyzer import TextAnalyzer
 import json
 
 # (Keep Constants as is)
@@ -15,41 +15,76 @@ DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 class BasicAgent:
     def __init__(self):
         print("BasicAgent initialized.")
-        self.analizar_historia = AmbiguityClassifier()
+        self.analyzer = TextAnalyzer()
         
-    def __call__(self, question: str) -> str:
-        print(f"Agent received question (first 50 chars): {question[:50]}...")
+    def __call__(self, text: str) -> str:
+        print(f"Agent received text (first 50 chars): {text[:50]}...")
         try:
-            resultado = self.analizar_historia(question)
+            resultado = self.analyzer(text)
             
-            # Formatear la respuesta
-            respuesta = []
-            if resultado["tiene_ambiguedad"]:
-                respuesta.append("Se encontraron las siguientes ambigüedades:")
-                
-                if resultado["ambiguedad_lexica"]:
-                    respuesta.append("\nAmbigüedades léxicas:")
-                    for amb in resultado["ambiguedad_lexica"]:
-                        respuesta.append(f"- {amb}")
-                
-                if resultado["ambiguedad_sintactica"]:
-                    respuesta.append("\nAmbigüedades sintácticas:")
-                    for amb in resultado["ambiguedad_sintactica"]:
-                        respuesta.append(f"- {amb}")
-                
-                respuesta.append(f"\nScore de ambigüedad: {resultado['score_ambiguedad']}")
-                respuesta.append("\nSugerencias de mejora:")
-                for sug in resultado["sugerencias"]:
-                    respuesta.append(f"- {sug}")
+            # Formatear la respuesta según el tipo de texto
+            if resultado.get("tipo") == "historia_usuario":
+                return self._format_user_story_response(resultado)
+            elif resultado.get("tipo") == "pregunta_general":
+                return self._format_general_question_response(resultado)
             else:
-                respuesta.append("No se encontraron ambigüedades en la historia de usuario.")
-                respuesta.append(f"Score de ambigüedad: {resultado['score_ambiguedad']}")
-            
-            return "\n".join(respuesta)
+                return f"Error: {resultado.get('error', 'Tipo de texto no reconocido')}"
         except Exception as e:
-            error_msg = f"Error analizando la historia: {str(e)}"
+            error_msg = f"Error analizando el texto: {str(e)}"
             print(error_msg)
             return error_msg
+    
+    def _format_user_story_response(self, resultado: dict) -> str:
+        """Formatea la respuesta para una historia de usuario."""
+        respuesta = []
+        if resultado["tiene_ambiguedad"]:
+            respuesta.append("Se encontraron las siguientes ambigüedades:")
+            
+            if resultado["ambiguedad_lexica"]:
+                respuesta.append("\nAmbigüedades léxicas:")
+                for amb in resultado["ambiguedad_lexica"]:
+                    respuesta.append(f"- {amb}")
+            
+            if resultado["ambiguedad_sintactica"]:
+                respuesta.append("\nAmbigüedades sintácticas:")
+                for amb in resultado["ambiguedad_sintactica"]:
+                    respuesta.append(f"- {amb}")
+            
+            respuesta.append(f"\nScore de ambigüedad: {resultado['score_ambiguedad']}")
+            respuesta.append("\nSugerencias de mejora:")
+            for sug in resultado["sugerencias"]:
+                respuesta.append(f"- {sug}")
+        else:
+            respuesta.append("No se encontraron ambigüedades en la historia de usuario.")
+            respuesta.append(f"Score de ambigüedad: {resultado['score_ambiguedad']}")
+        
+        return "\n".join(respuesta)
+    
+    def _format_general_question_response(self, resultado: dict) -> str:
+        """Formatea la respuesta para una pregunta general."""
+        analisis = resultado["analisis"]
+        respuesta = []
+        
+        respuesta.append("📝 Análisis de la pregunta:")
+        if analisis["is_question"]:
+            respuesta.append(f"• Tipo de pregunta: {analisis['question_type'] or 'No identificado'}")
+        
+        if analisis["entities"]:
+            respuesta.append("\n🏷️ Entidades identificadas:")
+            for ent, label in analisis["entities"]:
+                respuesta.append(f"• {ent} ({label})")
+        
+        if analisis["key_phrases"]:
+            respuesta.append("\n🔑 Frases clave identificadas:")
+            for phrase in analisis["key_phrases"]:
+                respuesta.append(f"• {phrase}")
+        
+        if resultado["sugerencias"]:
+            respuesta.append("\n💡 Sugerencias:")
+            for sug in resultado["sugerencias"]:
+                respuesta.append(f"• {sug}")
+        
+        return "\n".join(respuesta)
 
 def run_and_submit_all( profile: gr.OAuthProfile | None):
     """
@@ -173,78 +208,99 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
 
 
 # Inicializar el clasificador
-classifier = AmbiguityClassifier()
+classifier = TextAnalyzer()
 
-def analyze_user_story(user_story: str) -> str:
-    """Analiza una historia de usuario y retorna los resultados formateados."""
-    if not user_story.strip():
-        return "Por favor, ingrese una historia de usuario para analizar."
+def analyze_text(text: str) -> str:
+    """Analiza un texto y determina automáticamente si es una historia de usuario o una pregunta general."""
+    if not text.strip():
+        return "Por favor, ingrese un texto para analizar."
     
-    # Analizar la historia
-    result = classifier(user_story)
+    # Analizar el texto
+    result = classifier(text)
     
-    # Formatear resultados
+    # Formatear resultados según el tipo
     output = []
-    output.append(f"📝 Historia analizada:\n{user_story}\n")
-    output.append(f"🎯 Score de ambigüedad: {result['score_ambiguedad']}")
-    
-    if result['ambiguedad_lexica']:
-        output.append("\n📚 Ambigüedades léxicas encontradas:")
-        for amb in result['ambiguedad_lexica']:
-            output.append(f"• {amb}")
+    output.append(f"📝 Texto analizado:\n{text}\n")
     
-    if result['ambiguedad_sintactica']:
-        output.append("\n🔍 Ambigüedades sintácticas encontradas:")
-        for amb in result['ambiguedad_sintactica']:
-            output.append(f"• {amb}")
+    if result.get("tipo") == "historia_usuario":
+        output.append("📋 Tipo: Historia de Usuario")
+        output.append(f"🎯 Score de ambigüedad: {result['score_ambiguedad']}")
+        
+        if result['ambiguedad_lexica']:
+            output.append("\n📚 Ambigüedades léxicas encontradas:")
+            for amb in result['ambiguedad_lexica']:
+                output.append(f"• {amb}")
+        
+        if result['ambiguedad_sintactica']:
+            output.append("\n🔍 Ambigüedades sintácticas encontradas:")
+            for amb in result['ambiguedad_sintactica']:
+                output.append(f"• {amb}")
+        
+        if result['sugerencias']:
+            output.append("\n💡 Sugerencias de mejora:")
+            for sug in result['sugerencias']:
+                output.append(f"• {sug}")
     
-    if result['sugerencias']:
-        output.append("\n💡 Sugerencias de mejora:")
+    elif result.get("tipo") == "pregunta_general":
+        output.append("📋 Tipo: Pregunta General")
+        analisis = result['analisis']
+        
+        if analisis['is_question']:
+            output.append(f"❓ Tipo de pregunta: {analisis['question_type'] or 'No identificado'}")
+        
+        if analisis['entities']:
+            output.append("\n🏷️ Entidades identificadas:")
+            for ent, label in analisis['entities']:
+                output.append(f"• {ent} ({label})")
+        
+        if analisis['key_phrases']:
+            output.append("\n🔑 Frases clave:")
+            for phrase in analisis['key_phrases']:
+                output.append(f"• {phrase}")
+        
+        output.append("\n💡 Sugerencias:")
         for sug in result['sugerencias']:
             output.append(f"• {sug}")
     
+    else:
+        output.append("❌ Error: No se pudo determinar el tipo de texto")
+    
     return "\n".join(output)
 
-def analyze_multiple_stories(user_stories: str) -> str:
-    """Analiza múltiples historias de usuario separadas por líneas."""
-    if not user_stories.strip():
-        return "Por favor, ingrese al menos una historia de usuario para analizar."
+def analyze_multiple_texts(texts: str) -> str:
+    """Analiza múltiples textos separados por líneas."""
+    if not texts.strip():
+        return "Por favor, ingrese al menos un texto para analizar."
     
-    stories = [s.strip() for s in user_stories.split('\n') if s.strip()]
+    texts_list = [t.strip() for t in texts.split('\n') if t.strip()]
     all_results = []
     
-    for i, story in enumerate(stories, 1):
-        result = classifier(story)
-        story_result = {
-            "historia": story,
-            "score": result['score_ambiguedad'],
-            "ambiguedades_lexicas": result['ambiguedad_lexica'],
-            "ambiguedades_sintacticas": result['ambiguedad_sintactica'],
-            "sugerencias": result['sugerencias']
-        }
-        all_results.append(story_result)
+    for text in texts_list:
+        result = classifier(text)
+        result["texto_original"] = text
+        all_results.append(result)
     
     return json.dumps(all_results, indent=2, ensure_ascii=False)
 
 # --- Build Gradio Interface using Blocks ---
-with gr.Blocks(title="Detector de Ambigüedades en Historias de Usuario") as demo:
+with gr.Blocks(title="Analizador de Textos") as demo:
     gr.Markdown("""
-         # 🔍 Detector de Ambigüedades en Historias de Usuario
-    
-    Esta herramienta analiza historias de usuario en busca de ambigüedades léxicas y sintácticas, 
-    proporcionando sugerencias para mejorarlas.
+    # 🔍 Analizador de Textos
+
+    Esta herramienta analiza dos tipos de texto:
+    1. **Historias de Usuario**: Detecta ambigüedades léxicas y sintácticas
+    2. **Preguntas Generales**: Analiza estructura y contexto
     
     ## 📝 Instrucciones:
-    1. Ingrese una historia de usuario en el campo de texto
-    2. Haga clic en "Analizar"
-    3. Revise los resultados y las sugerencias de mejora
-        
+    1. Ingrese su texto en el campo correspondiente
+    2. El sistema detectará automáticamente el tipo de texto
+    3. Revise el análisis detallado y las sugerencias
     """)
 
     with gr.Tab("Análisis Individual"):
         input_text = gr.Textbox(
-            label="Historia de Usuario",
-            placeholder="Como usuario quiero...",
+            label="Texto a Analizar",
+            placeholder="Ingrese una historia de usuario o una pregunta general...",
             lines=3
         )
         analyze_btn = gr.Button("Analizar")
@@ -253,32 +309,37 @@ with gr.Blocks(title="Detector de Ambigüedades en Historias de Usuario") as dem
             lines=10
         )
         analyze_btn.click(
-            analyze_user_story,
+            analyze_text,
             inputs=[input_text],
             outputs=[output]
         )
     
     with gr.Tab("Análisis Múltiple"):
-        input_stories = gr.Textbox(
-            label="Historias de Usuario (una por línea)",
-            placeholder="Como usuario quiero...\nComo administrador necesito...",
+        input_texts = gr.Textbox(
+            label="Textos a Analizar (uno por línea)",
+            placeholder="Como usuario quiero...\n¿Cuál es el proceso para...?\n",
             lines=5
         )
-        analyze_multi_btn = gr.Button("Analizar Todas")
+        analyze_multi_btn = gr.Button("Analizar Todos")
         output_json = gr.JSON(label="Resultados del Análisis")
         analyze_multi_btn.click(
-            analyze_multiple_stories,
-            inputs=[input_stories],
+            analyze_multiple_texts,
+            inputs=[input_texts],
             outputs=[output_json]
         )
     
     gr.Markdown("""
-    ## 🚀 Ejemplos de Uso
-    
-    Pruebe con estas historias de usuario:
+    ## 🚀 Ejemplos
+
+    ### Historias de Usuario:
     - Como usuario quiero un sistema rápido y eficiente para gestionar mis tareas
     - El sistema debe permitir exportar varios tipos de archivos
     - Como administrador necesito acceder fácilmente a los reportes
+
+    ### Preguntas Generales:
+    - ¿Cuál es el proceso para recuperar una contraseña olvidada?
+    - ¿Cómo puedo generar un reporte mensual de ventas?
+    - ¿Dónde encuentro la documentación del API?
     """)
 
     gr.LoginButton()