Update app.py

app.py

@@ -3,378 +3,25 @@ import gradio as gr
 import requests
 import inspect
 import pandas as pd
-import json
-import time
-from typing import List, Dict, Any, Optional, Union
 
+# (Keep Constants as is)
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
-# --- Improved Agent Definition ---
-class GAIAAgent:
-    """
-    Agent optimizado para responder preguntas del nivel 1 de GAIA.
-    Utiliza un modelo de lenguaje grande (LLM) para generar respuestas.
-    """
-    def __init__(self, model_name="anthropic/claude-3-haiku-20240307"):
-        """
-        Inicializa el agente GAIA.
-        
-        Args:
-            model_name: Nombre del modelo a utilizar (por defecto claude-3-haiku)
-        """
-        self.model = self._initialize_model(model_name)
-        print(f"GAIAAgent initialized with model: {model_name}")
-        
-        # Instrucciones para responder preguntas
-        self.system_prompt = """
-        Eres un agente de IA diseñado para responder preguntas del GAIA (Generative AI Assessment) nivel 1.
-        Tu objetivo es proporcionar respuestas precisas, claras y concisas.
-        
-        Para preguntas de conocimiento general:
-        - Proporciona información factual y precisa
-        - Evita especulaciones o información no verificada
-        
-        Para razonamiento lógico:
-        - Descompón el problema en pasos lógicos
-        - Explica claramente tu razonamiento
-        
-        Para matemáticas:
-        - Muestra los pasos de tu cálculo
-        - Verifica tus respuestas
-        
-        Para instrucciones directas:
-        - Sigue exactamente lo que se te pide
-        - Proporciona exactamente lo solicitado, ni más ni menos
-        
-        Proporciona respuestas breves y al punto. No incluyas explicaciones adicionales a menos que sean necesarias.
-        """
-        
-    def _initialize_model(self, model_name):
-        """
-        Inicializa el modelo especificado. Configura los parámetros según el modelo elegido.
-        
-        Args:
-            model_name: Nombre/identificador del modelo a utilizar
-            
-        Returns:
-            str: Nombre del modelo configurado
-        """
-        # Configurar tokens de API si están disponibles
-        self.hf_token = os.getenv("HF_TOKEN")
-        self.openai_token = os.getenv("OPENAI_API_KEY") 
-        self.anthropic_token = os.getenv("ANTHROPIC_API_KEY")
-        
-        # Configuración específica según el modelo seleccionado
-        if "anthropic" in model_name or "claude" in model_name:
-            self.api_type = "anthropic"
-            if not self.anthropic_token:
-                print("⚠️ Anthropic API Key no encontrada. Se usará el sistema de fallback.")
-            else:
-                print(f"✅ Usando modelo Anthropic: {model_name}")
-                
-        elif "openai" in model_name or "gpt" in model_name:
-            self.api_type = "openai"
-            if not self.openai_token:
-                print("⚠️ OpenAI API Key no encontrada. Se usará el sistema de fallback.")
-            else:
-                print(f"✅ Usando modelo OpenAI: {model_name}")
-                
-        else:
-            # Por defecto usar HuggingFace Inference API
-            self.api_type = "huggingface"
-            if not self.hf_token:
-                print("⚠️ HuggingFace Token no encontrado. La API puede tener limitaciones de uso.")
-            print(f"✅ Usando modelo HuggingFace: {model_name}")
-        
-        return model_name
-    
-ios fundamentales, llegaría a una conclusión razonada."
-    
+# --- Basic Agent Definition ---
+# ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
+class BasicAgent:
+    def __init__(self):
+        print("BasicAgent initialized.")
     def __call__(self, question: str) -> str:
-        """
-        Procesa la pregunta y devuelve una respuesta.
-        
-        Args:
-            question: La pregunta o instrucción a responder
-            
-        Returns:
-            str: La respuesta generada
-        """
-        # Registrar la pregunta recibida
-        print(f"GAIAAgent recibió pregunta: {question[:100]}...")
-        
-        try:
-            # Análisis preliminar de la pregunta
-            question_type = self._analyze_question_type(question)
-            print(f"Tipo de pregunta detectado: {question_type}")
-            
-            # Preprocesamiento de la pregunta
-            processed_question = self._preprocess_question(question)
-            
-            # Para preguntas matemáticas simples, usar un solver específico
-            if question_type == "mathematical" and self._is_simple_math(processed_question):
-                try:
-                    math_answer = self._solve_math_problem(processed_question)
-                    if math_answer:
-                        return math_answer
-                except Exception as math_error:
-                    print(f"Error en cálculo matemático: {math_error}")
-                    # Continuar con el flujo normal
-            
-            # Llamada al modelo
-            response = self._call_api(processed_question)
-            
-            # Verificación de calidad de respuesta
-            if not response or len(response.strip()) < 5:
-                print("⚠️ Respuesta vacía o muy corta del modelo. Usando sistema de fallback.")
-                response = self._generate_fallback_response(question_type, processed_question)
-            
-            # Postprocesamiento de la respuesta
-            final_answer = self._postprocess_answer(response, question)
-            
-            print(f"GAIAAgent generó respuesta ({len(final_answer)} caracteres): {final_answer[:100]}...")
-            return final_answer
-            
-        except Exception as e:
-            error_msg = f"Error al procesar la pregunta: {str(e)}"
-            print(error_msg)
-            
-            # Intentar generar una respuesta de emergencia basada en el tipo de pregunta
-            try:
-                question_type = self._analyze_question_type(question)
-                fallback_response = self._generate_fallback_response(question_type, question)
-                return fallback_response
-            except:
-                # Respuesta de emergencia básica en caso de error total
-                return "Basado en mi análisis, la respuesta a esta pregunta involucra considerar múltiples factores relevantes y llegar a una conclusión lógica."
-                
-    def _analyze_question_type(self, question: str) -> str:
-        """
-        Analiza el tipo de pregunta para mejor direccionamiento.
-        
-        Args:
-            question: La pregunta a analizar
-            
-        Returns:
-            str: Tipo de pregunta detectado
-        """
-        question_lower = question.lower()
-        
-        # Verificación por palabras clave
-        if any(word in question_lower for word in ["suma", "resta", "multiplica", "divide", "calcula", 
-                                                  "cuánto es", "resultado de", "valor de", "+", "-", "*", "/"]):
-            return "mathematical"
-            
-        elif any(word in question_lower for word in ["capital de", "país", "continente", "ciudad", 
-                                                   "dónde está", "dónde se encuentra"]):
-            return "geographical"
-            
-        elif any(word in question_lower for word in ["quién", "autor", "escribió", "compuso", 
-                                                   "inventó", "descubrió", "creó"]):
-            return "factual_person"
-            
-        elif any(word in question_lower for word in ["cuándo", "fecha", "año", "siglo", "periodo"]):
-            return "factual_temporal"
-            
-        elif any(word in question_lower for word in ["qué es", "define", "definición", "significa", 
-                                                   "explica", "describe"]):
-            return "definitional"
-            
-        elif any(word in question_lower for word in ["cuál", "qué", "dónde"]):
-            return "factual_general"
-            
-        elif any(word in question_lower for word in ["por qué", "razón", "causa", "motivo"]):
-            return "explanatory"
-            
-        elif "si" in question_lower and any(word in question_lower for word in ["entonces", "luego", "por tanto"]):
-            return "logical"
-            
-        elif any(word in question_lower for word in ["cómo", "procedimiento", "pasos", "método"]):
-            return "procedural"
-            
-        elif any(word in question_lower for word in ["ordena", "clasifica", "enumera", "lista"]):
-            return "organizational"
-            
-        else:
-            return "general"
-            
-    def _is_simple_math(self, question: str) -> bool:
-        """
-        Determina si la pregunta es un problema matemático simple que se puede resolver directamente.
-        
-        Args:
-            question: La pregunta a analizar
-            
-        Returns:
-            bool: True si es un problema matemático simple
-        """
-        # Detectar patrones de operaciones matemáticas simples
-        import re
-        
-        # Buscar patrones numéricos con operadores
-        math_pattern = r'\b\d+\s*[\+\-\*\/]\s*\d+\b'
-        if re.search(math_pattern, question):
-            return True
-            
-        # Buscar números explícitos en la pregunta
-        numbers = re.findall(r'\b\d+\b', question)
-        if len(numbers) >= 2:
-            # Verificar si hay palabras clave de operación
-            ops = ["suma", "resta", "multiplica", "divide", "más", "menos", "por", "entre"]
-            if any(op in question.lower() for op in ops):
-                return True
-                
-        return False
-        
-    def _solve_math_problem(self, question: str) -> str:
-        """
-        Resuelve problemas matemáticos simples.
-        
-        Args:
-            question: La pregunta matemática
-            
-        Returns:
-            str: La respuesta calculada
-        """
-        import re
-        
-        # Limpiamos y preparamos el texto
-        math_text = question.lower().replace('?', '').strip()
-        
-        # Extraer números
-        numbers = re.findall(r'\b\d+\.?\d*\b', math_text)
-        if len(numbers) < 2:
-            return ""
-            
-        # Determinar operación
-        operation = None
-        if any(op in math_text for op in ["suma", "más", "sumar", "adicionar", "+"]):
-            operation = "suma"
-        elif any(op in math_text for op in ["resta", "menos", "restar", "diferencia", "-"]):
-            operation = "resta"
-        elif any(op in math_text for op in ["multiplica", "por", "multiplicar", "producto", "*", "x"]):
-            operation = "multiplicacion"
-        elif any(op in math_text for op in ["divide", "entre", "dividir", "cociente", "/", "÷"]):
-            operation = "division"
-        else:
-            return ""
-            
-        # Realizar cálculo
-        try:
-            num1 = float(numbers[0])
-            num2 = float(numbers[1])
-            
-            if operation == "suma":
-                result = num1 + num2
-                return f"La suma de {num1} y {num2} es {result}"
-            elif operation == "resta":
-                result = num1 - num2
-                return f"La resta de {num1} menos {num2} es {result}"
-            elif operation == "multiplicacion":
-                result = num1 * num2
-                return f"La multiplicación de {num1} por {num2} es {result}"
-            elif operation == "division":
-                if num2 == 0:
-                    return "No se puede dividir por cero."
-                result = num1 / num2
-                return f"La división de {num1} entre {num2} es {result}"
-                
-        except Exception as e:
-            print(f"Error en cálculo: {e}")
-            return ""
-            
-        return ""
-        
-    def _generate_fallback_response(self, question_type: str, question: str) -> str:
-        """
-        Genera una respuesta de fallback basada en el tipo de pregunta.
-        
-        Args:
-            question_type: Tipo de pregunta identificado
-            question: La pregunta original
-            
-        Returns:
-            str: Respuesta de fallback
-        """
-        # Respuestas específicas para cada tipo de pregunta
-        if question_type == "mathematical":
-            return "Para resolver este problema matemático, analizaría los valores y aplicaría las operaciones aritméticas necesarias para obtener el resultado correcto."
-            
-        elif question_type == "geographical":
-            return "Según mi conocimiento de geografía mundial, esta ubicación se encuentra en la región correspondiente, considerando sus características geopolíticas y físicas."
-            
-        elif question_type == "factual_person":
-            return "Basado en los registros históricos y biográficos, esta persona es conocida por sus contribuciones significativas en su campo de especialización."
-            
-        elif question_type == "factual_temporal":
-            return "Este evento ocurrió en el período histórico relevante, considerando el contexto cronológico y los acontecimientos relacionados de la época."
-            
-        elif question_type == "definitional":
-            return "Este concepto se refiere a un conjunto de principios y elementos interrelacionados que constituyen un campo específico del conocimiento, con aplicaciones prácticas y teóricas."
-            
-        elif question_type == "explanatory":
-            return "Este fenómeno se explica por la combinación de factores causales que interactúan de manera compleja, generando el resultado observado a través de mecanismos específicos."
-            
-        elif question_type == "logical":
-            return "Siguiendo los principios de razonamiento lógico, si se aceptan las premisas dadas, entonces la conclusión válida sería la que se deriva directamente de ellas."
-            
-        elif question_type == "procedural":
-            return "El procedimiento adecuado consiste en seguir una secuencia de pasos ordenados para lograr el objetivo, cumpliendo con los requisitos y estándares establecidos."
-            
-        else:
-            return "Basado en un análisis comprehensivo de la información disponible, la respuesta más precisa considera múltiples factores y perspectivas relevantes para este tema."
-    
-    def _preprocess_question(self, question: str) -> str:
-        """
-        Preprocesa la pregunta para mejorar la calidad de la respuesta.
-        
-        Args:
-            question: La pregunta original
-            
-        Returns:
-            str: La pregunta procesada
-        """
-        # Limpieza básica
-        processed = question.strip()
-        
-        # Asegurarse de que termina con signo de interrogación si es una pregunta
-        if not processed.endswith('?') and ('?' in processed or any(word in processed.lower() for word in 
-                                           ["qué", "cómo", "cuándo", "dónde", "por qué", "cuál", "quién"])):
-            processed += '?'
-            
-        return processed
-    
-    def _postprocess_answer(self, answer: str, original_question: str) -> str:
-        """
-        Postprocesa la respuesta para asegurar calidad y relevancia.
-        
-        Args:
-            answer: La respuesta generada por el modelo
-            original_question: La pregunta original
-            
-        Returns:
-            str: La respuesta procesada
-        """
-        # Limpieza básica
-        processed = answer.strip()
-        
-        # Asegurarse de que la respuesta no es demasiado larga
-        if len(processed) > 1000:
-            # Truncar y añadir indicador
-            processed = processed[:997] + "..."
-            
-        # Asegurarse de que la respuesta no es vacía
-        if not processed:
-            processed = "Basado en la información disponible, la respuesta más precisa sería una evaluación cuidadosa de los factores relevantes."
-            
-        return processed
+        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
 
-
-# --- Modificar la función run_and_submit_all para usar nuestro nuevo agente ---
-def run_and_submit_all(profile: gr.OAuthProfile | None):
+def run_and_submit_all( profile: gr.OAuthProfile | None):
     """
-    Fetches all questions, runs the GAIAAgent on them, submits all answers,
+    Fetches all questions, runs the BasicAgent on them, submits all answers,
     and displays the results.
     """
     # --- Determine HF Space Runtime URL and Repo URL ---
@@ -391,13 +38,13 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
     questions_url = f"{api_url}/questions"
     submit_url = f"{api_url}/submit"
 
-    # 1. Instantiate Agent (reemplazamos BasicAgent con nuestro GAIAAgent)
+    # 1. Instantiate Agent ( modify this part to create your agent)
     try:
-        agent = GAIAAgent()
+        agent = BasicAgent()
     except Exception as e:
         print(f"Error instantiating agent: {e}")
         return f"Error initializing agent: {e}", None
-    # In the case of an app running as a hugging Face space, this link points toward your codebase
+    # In the case of an app running as a hugging Face space, this link points toward your codebase ( usefull for others so please keep it public)
     agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
     print(agent_code)
 
@@ -490,4 +137,58 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
         status_message = f"An unexpected error occurred during submission: {e}"
         print(status_message)
         results_df = pd.DataFrame(results_log)
-        return status_message, results_df
+        return status_message, results_df
+
+
+# --- 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")
+
+    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)
+
+    run_button.click(
+        fn=run_and_submit_all,
+        outputs=[status_output, results_table]
+    )
+
+if __name__ == "__main__":
+    print("\n" + "-"*30 + " App Starting " + "-"*30)
+    # Check for SPACE_HOST and SPACE_ID at startup for information
+    space_host_startup = os.getenv("SPACE_HOST")
+    space_id_startup = os.getenv("SPACE_ID") # Get SPACE_ID at startup
+
+    if space_host_startup:
+        print(f"✅ SPACE_HOST found: {space_host_startup}")
+        print(f"   Runtime URL should be: https://{space_host_startup}.hf.space")
+    else:
+        print("ℹ️  SPACE_HOST environment variable not found (running locally?).")
+
+    if space_id_startup: # Print repo URLs if SPACE_ID is found
+        print(f"✅ SPACE_ID found: {space_id_startup}")
+        print(f"   Repo URL: https://huggingface.co/spaces/{space_id_startup}")
+        print(f"   Repo Tree URL: https://huggingface.co/spaces/{space_id_startup}/tree/main")
+    else:
+        print("ℹ️  SPACE_ID environment variable not found (running locally?). Repo URL cannot be determined.")
+
+    print("-"*(60 + len(" App Starting ")) + "\n")
+
+    print("Launching Gradio Interface for Basic Agent Evaluation...")
+    demo.launch(debug=True, share=False)