Upload 3 files

app.py

@@ -3,6 +3,8 @@ import gradio as gr
 import requests
 import inspect
 import pandas as pd
+from agent import AmbiguityClassifier
+import json
 
 # (Keep Constants as is)
 # --- Constants ---
@@ -11,13 +13,44 @@ DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 # --- Basic Agent Definition ---
 # ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
 class BasicAgent:
+    """A langgraph agent that detects and classifies ambiguities in user stories."""
     def __init__(self):
         print("BasicAgent initialized.")
+        self.analizar_historia = AmbiguityClassifier()
+      
     def __call__(self, question: str) -> str:
         print(f"Agent received question (first 50 chars): {question[:50]}...")
-        fixed_answer = "This is a default answer."
-        print(f"Agent returning fixed answer: {fixed_answer}")
-        return fixed_answer
+        try:
+            resultado = self.analizar_historia(question)
+            
+            # 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}")
+            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)
+        except Exception as e:
+            error_msg = f"Error analizando la historia: {str(e)}"
+            print(error_msg)
+            return error_msg
 
 def run_and_submit_all( profile: gr.OAuthProfile | None):
     """
@@ -139,37 +172,113 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
         results_df = pd.DataFrame(results_log)
         return status_message, results_df
 
+# Inicializar el clasificador
+classifier = AmbiguityClassifier()
 
-# --- Build Gradio Interface using Blocks ---
-with gr.Blocks() as demo:
-    gr.Markdown("# Basic Agent Evaluation Runner")
-    gr.Markdown(
-        """
-        **Instructions:**
-
-        1.  Please clone this space, then modify the code to define your agent's logic, the tools, the necessary packages, etc ...
-        2.  Log in to your Hugging Face account using the button below. This uses your HF username for submission.
-        3.  Click 'Run Evaluation & Submit All Answers' to fetch questions, run your agent, submit answers, and see the score.
-
-        ---
-        **Disclaimers:**
-        Once clicking on the "submit button, it can take quite some time ( this is the time for the agent to go through all the questions).
-        This space provides a basic setup and is intentionally sub-optimal to encourage you to develop your own, more robust solution. For instance for the delay process of the submit button, a solution could be to cache the answers and submit in a seperate action or even to answer the questions in async.
-        """
-    )
-
-    gr.LoginButton()
-
-    run_button = gr.Button("Run Evaluation & Submit All Answers")
+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."
+    
+    # Analizar la historia
+    result = classifier(user_story)
+    
+    # Formatear resultados
+    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}")
+    
+    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}")
+    
+    return "\n".join(output)
 
-    status_output = gr.Textbox(label="Run Status / Submission Result", lines=5, interactive=False)
-    # Removed max_rows=10 from DataFrame constructor
-    results_table = gr.DataFrame(label="Questions and Agent Answers", wrap=True)
+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."
+    
+    stories = [s.strip() for s in user_stories.split('\n') if s.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)
+    
+    return json.dumps(all_results, indent=2, ensure_ascii=False)
 
-    run_button.click(
-        fn=run_and_submit_all,
-        outputs=[status_output, results_table]
-    )
+# Crear la interfaz
+with gr.Blocks(title="Detector de Ambigüedades en Historias de Usuario") 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.
+    
+    ## 📝 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
+    """)
+    
+    with gr.Tab("Análisis Individual"):
+        input_text = gr.Textbox(
+            label="Historia de Usuario",
+            placeholder="Como usuario quiero...",
+            lines=3
+        )
+        analyze_btn = gr.Button("Analizar")
+        output = gr.Textbox(
+            label="Resultados del Análisis",
+            lines=10
+        )
+        analyze_btn.click(
+            analyze_user_story,
+            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...",
+            lines=5
+        )
+        analyze_multi_btn = gr.Button("Analizar Todas")
+        output_json = gr.JSON(label="Resultados del Análisis")
+        analyze_multi_btn.click(
+            analyze_multiple_stories,
+            inputs=[input_stories],
+            outputs=[output_json]
+        )
+    
+    gr.Markdown("""
+    ## 🚀 Ejemplos de Uso
+    
+    Pruebe con estas 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
+    """)
 
 if __name__ == "__main__":
     print("\n" + "-"*30 + " App Starting " + "-"*30)

patterns.py

@@ -0,0 +1,206 @@
+"""
+Patrones comunes de ambigüedad en historias de usuario.
+"""
+
+AMBIGUITY_PATTERNS = {
+    "lexicos": {
+        # Palabras con múltiples significados comunes
+        "fácil", "simple", "rápido", "eficiente",
+        "mejor", "adecuado", "apropiado",
+        "flexible", "dinámico", "intuitivo",
+        "amigable", "óptimo", "robusto",
+        
+        # Cuantificadores ambiguos
+        "algunos", "varios", "muchos", "pocos",
+        "más", "menos", "suficiente",
+        "bastante", "demasiado", "aproximadamente",
+        
+        # Temporales ambiguos
+        "pronto", "rápidamente", "periódicamente",
+        "regularmente", "ocasionalmente", "frecuentemente",
+        "en tiempo real", "instantáneamente", "ágilmente",
+        
+        # Calificadores ambiguos
+        "moderno", "innovador", "avanzado",
+        "inteligente", "sofisticado", "elegante",
+        
+        # Términos de usabilidad ambiguos
+        "user-friendly", "intuitivo", "natural",
+        "seamless", "fluido", "sin problemas"
+    },
+    
+    "sintacticos": {
+        # Patrones de estructura ambigua
+        r"(.*?) y (.*?) con (.*?)",  # Ambigüedad de alcance de "con"
+        r"no (.*?) y (.*?)",  # Ambigüedad de alcance de negación
+        r"(.*?) o (.*?) y (.*?)",  # Ambigüedad de operadores lógicos
+        r"(.*?) pero (.*?) si (.*?)",  # Condiciones ambiguas
+        r"(.*?) cuando (.*?) o (.*?)",  # Temporalidad ambigua
+        r"(.*?) excepto (.*?) y (.*?)",  # Exclusiones ambiguas
+        r"(.*?) antes de (.*?) y (.*?)",  # Secuencia temporal ambigua
+        r"(.*?) después de (.*?) o (.*?)",  # Secuencia condicional ambigua
+    },
+    
+    "semanticos": {
+        # Frases que suelen indicar ambigüedad
+        "si es posible",
+        "cuando sea necesario",
+        "si se requiere",
+        "según corresponda",
+        "como sea apropiado",
+        "en caso de ser necesario",
+        "dependiendo del caso",
+        "si aplica",
+        "cuando corresponda",
+        "si es factible",
+        "en la medida de lo posible",
+        "siempre que sea posible"
+    },
+    
+    "contextuales": {
+        # Dependencias implícitas
+        r"(?i)similar a (.*?)",  # Referencias vagas
+        r"(?i)como en (.*?)",   # Comparaciones ambiguas
+        r"(?i)igual que (.*?)", # Referencias no específicas
+        
+        # Suposiciones de conocimiento
+        r"(?i)de la manera usual",
+        r"(?i)como siempre",
+        r"(?i)de forma estándar",
+        
+        # Referencias ambiguas
+        r"(?i)esto",
+        r"(?i)eso",
+        r"(?i)aquello",
+        r"(?i)lo mismo"
+    }
+}
+
+# Términos técnicos que no son ambiguos en el contexto
+TECHNICAL_TERMS = {
+    # Autenticación y Seguridad
+    "OAuth", "autenticación", "autorización",
+    "token", "JWT", "SSO", "2FA", "MFA",
+    
+    # Datos y Almacenamiento
+    "base de datos", "SQL", "NoSQL", "cache",
+    "índice", "backup", "restauración",
+    
+    # Frontend
+    "responsive", "CSS", "HTML", "JavaScript",
+    "React", "Angular", "Vue", "DOM",
+    
+    # Backend
+    "API", "REST", "GraphQL", "webhook",
+    "microservicio", "contenedor", "Docker",
+    
+    # Operaciones
+    "logging", "monitoreo", "alertas",
+    "deployment", "CI/CD", "pipeline",
+    
+    # Términos de negocio
+    "ROI", "KPI", "SLA", "métrica",
+    "dashboard", "reporte", "análisis"
+}
+
+# Patrones de estructura de historia de usuario
+USER_STORY_PATTERNS = {
+    'estandar': r"(?i)^como\s+(.+?),?\s+quiero\s+(.+?)(?:\s+para\s+(?:que\s+)?(.+))?$",
+    'modal': r"(?i)^(?:un|una|el|la)\s+(.+?)\s+(?:puede|debe|debería)\s+(.+?)(?:\s+para\s+(?:que\s+)?(.+))?$",
+    'pasiva': r"(?i)^(?:el|la|los|las)\s+(.+?)\s+(?:debe|deben|debería|deberían)\s+(?:ser|estar)\s+(.+?)(?:\s+para\s+(?:que\s+)?(.+))?$",
+    'declarativa': r"(?i)^(?:los|las)\s+(.+?)\s+(?:deben|deberían)\s+(.+?)(?:\s+para\s+(?:que\s+)?(.+))?$",
+    'necesidad': r"(?i)^(?:necesito|necesitamos|se\s+necesita)\s+(.+?)(?:\s+para\s+(?:que\s+)?(.+))?$",
+    'deseo': r"(?i)^(?:deseo|deseamos|se\s+desea)\s+(.+?)(?:\s+para\s+(?:que\s+)?(.+))?$"
+}
+
+# Patrones para detectar ambigüedades léxicas
+PATRONES_AMBIGUEDAD_LEXICA = [
+    {
+        "patron": r"\b(rápido|eficiente|fácil|simple|intuitivo|amigable|flexible|robusto)\b(?![^{]*\})",
+        "tipo": "adjetivo_subjetivo",
+        "descripcion": "Uso de adjetivos subjetivos que pueden interpretarse de diferentes maneras"
+    },
+    {
+        "patron": r"\b(varios|algunos|muchos|pocos|diversos|múltiples)\b(?!\s+(?:formatos?|tipos?|archivos?|reportes?)\s+(?:como|:|\(|\{))",
+        "tipo": "cuantificador_ambiguo",
+        "descripcion": "Uso de cuantificadores ambiguos que no especifican una cantidad concreta"
+    },
+    {
+        "patron": r"\b(etc|etcétera|entre otros|y más|y otros)\b",
+        "tipo": "enumeracion_incompleta",
+        "descripcion": "Uso de expresiones que dejan la enumeración incompleta o abierta"
+    },
+    {
+        "patron": r"\b(sistema|aplicación|plataforma|herramienta|solución)\b(?!\s+(?:debe|debería|tiene que|ha de))",
+        "tipo": "termino_generico",
+        "descripcion": "Uso de términos genéricos que no especifican la funcionalidad concreta"
+    }
+]
+
+# Patrones para detectar ambigüedades sintácticas
+PATRONES_AMBIGUEDAD_SINTACTICA = [
+    {
+        "patron": r"(?i)(?<![\w{])(y|o|y/o)(?!\s+(?:\d+|\{|\w+\s*[=:<>]))",
+        "tipo": "coordinacion_ambigua",
+        "descripcion": "Uso de coordinaciones que pueden crear ambigüedad en la interpretación"
+    },
+    {
+        "patron": r"(?i)\b(esto|eso|aquello|el cual|la cual|lo cual|que)\b(?!\s+(?:significa|implica|requiere|incluye))",
+        "tipo": "referencia_ambigua",
+        "descripcion": "Uso de referencias ambiguas que pueden tener múltiples antecedentes"
+    },
+    {
+        "patron": r"(?i)\b(si|cuando|mientras|después|antes|luego)\b(?!\s+(?:el|la|los|las|se)\s+(?:\w+\s+){0,3}(?:\d+|específico|definido))",
+        "tipo": "condicion_temporal_ambigua",
+        "descripcion": "Uso de condiciones o referencias temporales ambiguas"
+    },
+    {
+        "patron": r"(?i)(poder|deber|necesitar|querer)\s+\w+\s+(y|o)\s+\w+(?!\s+(?:en|durante|cada|por)\s+(?:\d+|un|una)\s+(?:segundo|minuto|hora)s?)",
+        "tipo": "alcance_verbo_modal",
+        "descripcion": "Ambigüedad en el alcance de verbos modales con múltiples acciones"
+    }
+]
+
+# Sugerencias de mejora para cada tipo de ambigüedad
+SUGERENCIAS_MEJORA = {
+    "adjetivo_subjetivo": [
+        "Especificar métricas o criterios medibles (ej: tiempo de respuesta en segundos)",
+        "Definir valores concretos o rangos aceptables",
+        "Usar términos más específicos y cuantificables"
+    ],
+    "cuantificador_ambiguo": [
+        "Especificar cantidades exactas o rangos definidos",
+        "Listar explícitamente los elementos o tipos",
+        "Definir límites mínimos y máximos"
+    ],
+    "enumeracion_incompleta": [
+        "Listar todos los elementos requeridos",
+        "Especificar criterios de inclusión/exclusión",
+        "Definir el alcance completo de la funcionalidad"
+    ],
+    "termino_generico": [
+        "Especificar la funcionalidad concreta",
+        "Describir las características técnicas específicas",
+        "Detallar los componentes o módulos involucrados"
+    ],
+    "coordinacion_ambigua": [
+        "Separar en historias de usuario independientes",
+        "Usar listas numeradas o viñetas para clarificar",
+        "Especificar la relación entre los elementos"
+    ],
+    "referencia_ambigua": [
+        "Repetir el sustantivo al que se hace referencia",
+        "Usar referencias específicas y directas",
+        "Evitar pronombres ambiguos"
+    ],
+    "condicion_temporal_ambigua": [
+        "Especificar intervalos de tiempo exactos",
+        "Definir el orden preciso de las acciones",
+        "Usar referencias temporales específicas (ej: cada 5 minutos)"
+    ],
+    "alcance_verbo_modal": [
+        "Separar las acciones en requisitos independientes",
+        "Especificar las condiciones para cada acción",
+        "Definir la prioridad o secuencia de las acciones"
+    ]
+} 

requirements.txt

@@ -1,2 +1,14 @@
-gradio
-requests
+gradio>=5.25.2
+requests
+spacy>=3.7.0
+es-core-news-sm @ https://github.com/explosion/spacy-models/releases/download/es_core_news_sm-3.7.0/es_core_news_sm-3.7.0-py3-none-any.whl
+pytest>=8.0.0
+typing-extensions>=4.9.0
+nltk>=3.8.1
+gradio>=4.19.2
+requests>=2.31.0
+pandas>=2.2.0
+transformers>=4.30.0
+torch>=2.0.0
+numpy>=1.24.0
+setuptools>=69.1.0