Update app.py

app.py

@@ -1,348 +1,216 @@
-""" Advanced Agent Evaluation Runner"""
+""" Basic Agent Evaluation Runner"""
 import os
 import inspect
 import gradio as gr
 import requests
 import pandas as pd
-import json
 from agent.agent import chat_with_agent
 
+
+
 # (Keep Constants as is)
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
-# --- Advanced Agent Definition ---
+# --- Basic Agent Definition ---
 # ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
-class AdvancedAgent:
-    def __init__(self):
-        print("AdvancedAgent initialized with tools and capabilities.")
-        
+
+
+class BasicAgent:
     def __call__(self, question: str) -> dict:
-        """
-        Process a question and return a structured response with answer and reasoning.
-        Returns: {"model_answer": "answer", "reasoning_trace": "reasoning"}
-        """
         print(f"Agent received question (first 50 chars): {question[:50]}...")
+        # Get response from the agent
+        answer = chat_with_agent(question)
         
-        try:
-            # Get response from the agent
-            response = chat_with_agent(question)
-            
-            # Extract the final answer from the response
-            # The agent is configured to end with "FINAL ANSWER: [answer]"
-            if "FINAL ANSWER:" in response:
-                # Extract everything after "FINAL ANSWER:"
-                final_answer = response.split("FINAL ANSWER:")[-1].strip()
-                # Remove any extra formatting or newlines
-                final_answer = final_answer.replace('\n', ' ').strip()
-            else:
-                # If no FINAL ANSWER format, use the whole response
-                final_answer = response.strip()
-            
-            # Create the reasoning trace (the full response without the final answer)
-            reasoning_trace = response.strip()
-            
-            return {
-                "model_answer": final_answer,
-                "reasoning_trace": reasoning_trace
-            }
-            
-        except Exception as e:
-            print(f"Error in agent processing: {e}")
-            return {
-                "model_answer": f"Error: {str(e)}",
-                "reasoning_trace": f"Agent encountered an error while processing the question: {str(e)}"
-            }
+        # Return in the format expected by the API
+        return {
+            "model_answer": answer,
+            "reasoning_trace": answer  # Using the full response as reasoning trace
+        }
+
 
 def run_and_submit_all( profile: gr.OAuthProfile | None):
     """
-    Fetches all questions, runs the AdvancedAgent on them, submits all answers,
+    Fetches all questions, runs the BasicAgent on them, submits all answers,
     and displays the results.
     """
-    try:
-        # --- Determine HF Space Runtime URL and Repo URL ---
-        space_id = os.getenv("SPACE_ID") # Get the SPACE_ID for sending link to the code
+    # --- Determine HF Space Runtime URL and Repo URL ---
+    space_id = os.getenv("SPACE_ID") # Get the SPACE_ID for sending link to the code
 
-        if profile:
-            username= f"{profile.username}"
-            print(f"User logged in: {username}")
-        else:
-            print("User not logged in.")
-            return "Please Login to Hugging Face with the button.", None
+    if profile:
+        username= f"{profile.username}"
+        print(f"User logged in: {username}")
+    else:
+        print("User not logged in.")
+        return "Please Login to Hugging Face with the button.", None
 
-        api_url = DEFAULT_API_URL
-        questions_url = f"{api_url}/questions"
-        submit_url = f"{api_url}/submit"
+    api_url = DEFAULT_API_URL
+    questions_url = f"{api_url}/questions"
+    submit_url = f"{api_url}/submit"
 
-        # 1. Instantiate Agent ( modify this part to create your agent)
+    # 1. Instantiate Agent ( modify this part to create your agent)
+    try:
+        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 ( usefull for others so please keep it public)
+    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
+    print(agent_code)
+
+    # 2. Fetch Questions
+    print(f"Fetching questions from: {questions_url}")
+    try:
+        response = requests.get(questions_url, timeout=15)
+        response.raise_for_status()
+        questions_data = response.json()
+        if not questions_data:
+             print("Fetched questions list is empty.")
+             return "Fetched questions list is empty or invalid format.", None
+        print(f"Fetched {len(questions_data)} questions.")
+    except requests.exceptions.RequestException as e:
+        print(f"Error fetching questions: {e}")
+        return f"Error fetching questions: {e}", None
+    except requests.exceptions.JSONDecodeError as e:
+         print(f"Error decoding JSON response from questions endpoint: {e}")
+         print(f"Response text: {response.text[:500]}")
+         return f"Error decoding server response for questions: {e}", None
+    except Exception as e:
+        print(f"An unexpected error occurred fetching questions: {e}")
+        return f"An unexpected error occurred fetching questions: {e}", None
+
+    # 3. Run your Agent
+    results_log = []
+    answers_payload = []
+    print(f"Running agent on {len(questions_data)} questions...")
+    for item in questions_data:
+        task_id = item.get("task_id")
+        question_text = item.get("question")
+        if not task_id or question_text is None:
+            print(f"Skipping item with missing task_id or question: {item}")
+            continue
         try:
-            agent = AdvancedAgent()
+            # Get structured response from agent
+            agent_response = agent(question_text)
+            
+            # Extract model_answer and reasoning_trace
+            model_answer = agent_response.get("model_answer", "")
+            reasoning_trace = agent_response.get("reasoning_trace", "")
+            
+            # Create JSON-line format entry
+            json_line_entry = {
+                "task_id": task_id,
+                "model_answer": model_answer,
+                "reasoning_trace": reasoning_trace
+            }
+            
+            answers_payload.append(json_line_entry)
+            
+            # For display in the table, show truncated versions
+            display_question = question_text[:200] + "..." if len(question_text) > 200 else question_text
+            display_answer = model_answer[:200] + "..." if len(model_answer) > 200 else model_answer
+            
+            results_log.append({
+                "Task ID": task_id, 
+                "Question": display_question, 
+                "Model Answer": display_answer
+            })
+            
         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 ( usefull for others so please keep it public)
-        agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main" if space_id else "https://huggingface.co/spaces/your-space-id/tree/main"
-        print(agent_code)
-
-        # 2. Fetch Questions
-        print(f"Fetching questions from: {questions_url}")
+             print(f"Error running agent on task {task_id}: {e}")
+             error_response = {
+                 "task_id": task_id,
+                 "model_answer": f"AGENT ERROR: {e}",
+                 "reasoning_trace": f"Agent encountered an error while processing the question: {str(e)}"
+             }
+             answers_payload.append(error_response)
+             results_log.append({
+                 "Task ID": task_id, 
+                 "Question": question_text[:200] + "..." if question_text and len(question_text) > 200 else question_text, 
+                 "Model Answer": f"AGENT ERROR: {e}"
+             })
+
+    if not answers_payload:
+        print("Agent did not produce any answers to submit.")
+        return "Agent did not produce any answers to submit.", pd.DataFrame(results_log)
+
+    # 4. Prepare Submission 
+    submission_data = {"username": username.strip(), "agent_code": agent_code, "answers": answers_payload}
+    status_update = f"Agent finished. Submitting {len(answers_payload)} answers for user '{username}'..."
+    print(status_update)
+
+    # 5. Submit
+    print(f"Submitting {len(answers_payload)} answers to: {submit_url}")
+    try:
+        response = requests.post(submit_url, json=submission_data, timeout=60)
+        response.raise_for_status()
+        result_data = response.json()
+        final_status = (
+            f"Submission Successful!\n"
+            f"User: {result_data.get('username')}\n"
+            f"Overall Score: {result_data.get('score', 'N/A')}% "
+            f"({result_data.get('correct_count', '?')}/{result_data.get('total_attempted', '?')} correct)\n"
+            f"Message: {result_data.get('message', 'No message received.')}"
+        )
+        print("Submission successful.")
+        results_df = pd.DataFrame(results_log)
+        return final_status, results_df
+    except requests.exceptions.HTTPError as e:
+        error_detail = f"Server responded with status {e.response.status_code}."
         try:
-            response = requests.get(questions_url, timeout=15)
-            response.raise_for_status()
-            questions_data = response.json()
-            if not questions_data:
-                 print("Fetched questions list is empty.")
-                 return "Fetched questions list is empty or invalid format.", None
-            print(f"Fetched {len(questions_data)} questions.")
-        except requests.exceptions.RequestException as e:
-            print(f"Error fetching questions: {e}")
-            return f"Error fetching questions: {e}", None
-        except requests.exceptions.JSONDecodeError as e:
-             print(f"Error decoding JSON response from questions endpoint: {e}")
-             print(f"Response text: {response.text[:500]}")
-             return f"Error decoding server response for questions: {e}", None
-        except Exception as e:
-            print(f"An unexpected error occurred fetching questions: {e}")
-            return f"An unexpected error occurred fetching questions: {e}", None
+            error_json = e.response.json()
+            error_detail += f" Detail: {error_json.get('detail', e.response.text)}"
+        except requests.exceptions.JSONDecodeError:
+            error_detail += f" Response: {e.response.text[:500]}"
+        status_message = f"Submission Failed: {error_detail}"
+        print(status_message)
+        results_df = pd.DataFrame(results_log)
+        return status_message, results_df
+    except requests.exceptions.Timeout:
+        status_message = "Submission Failed: The request timed out."
+        print(status_message)
+        results_df = pd.DataFrame(results_log)
+        return status_message, results_df
+    except requests.exceptions.RequestException as e:
+        status_message = f"Submission Failed: Network error - {e}"
+        print(status_message)
+        results_df = pd.DataFrame(results_log)
+        return status_message, results_df
+    except Exception as e:
+        status_message = f"An unexpected error occurred during submission: {e}"
+        print(status_message)
+        results_df = pd.DataFrame(results_log)
+        return status_message, results_df
 
-        # 3. Run your Agent
-        results_log = []
-        answers_payload = []
-        print(f"Running agent on {len(questions_data)} questions...")
-        for item in questions_data:
-            task_id = item.get("task_id")
-            question_text = item.get("question")
-            if not task_id or question_text is None:
-                print(f"Skipping item with missing task_id or question: {item}")
-                continue
-            try:
-                # Get structured response from agent
-                agent_response = agent(question_text)
-                
-                # Extract model_answer and reasoning_trace
-                model_answer = agent_response.get("model_answer", "")
-                reasoning_trace = agent_response.get("reasoning_trace", "")
-                
-                # Ensure the answer is a string and not too long
-                if not isinstance(model_answer, str):
-                    model_answer = str(model_answer)
-                if len(model_answer) > 10000:  # Limit answer length
-                    model_answer = model_answer[:10000] + "..."
-                
-                # Ensure reasoning_trace is a string and not too long
-                if not isinstance(reasoning_trace, str):
-                    reasoning_trace = str(reasoning_trace)
-                if len(reasoning_trace) > 50000:  # Limit reasoning length
-                    reasoning_trace = reasoning_trace[:50000] + "..."
-                
-                # Create JSON-line format entry
-                json_line_entry = {
-                    "task_id": task_id,
-                    "model_answer": model_answer,
-                    "reasoning_trace": reasoning_trace
-                }
-                
-                answers_payload.append(json_line_entry)
-                
-                # For display in the table, show truncated versions
-                display_question = question_text[:200] + "..." if len(question_text) > 200 else question_text
-                display_answer = model_answer[:200] + "..." if len(model_answer) > 200 else model_answer
-                display_reasoning = reasoning_trace[:200] + "..." if len(reasoning_trace) > 200 else reasoning_trace
-                
-                results_log.append({
-                    "Task ID": task_id, 
-                    "Question": display_question, 
-                    "Model Answer": display_answer,
-                    "Reasoning Trace": display_reasoning
-                })
-                
-            except Exception as e:
-                 print(f"Error running agent on task {task_id}: {e}")
-                 error_response = {
-                     "task_id": task_id,
-                     "model_answer": f"AGENT ERROR: {e}",
-                     "reasoning_trace": f"Agent encountered an error while processing the question: {str(e)}"
-                 }
-                 answers_payload.append(error_response)
-                 results_log.append({
-                     "Task ID": task_id, 
-                     "Question": question_text[:200] + "..." if question_text and len(question_text) > 200 else question_text, 
-                     "Model Answer": f"AGENT ERROR: {e}",
-                     "Reasoning Trace": f"Error occurred during processing"
-                 })
 
-        if not answers_payload:
-            print("Agent did not produce any answers to submit.")
-            return "Agent did not produce any answers to submit.", pd.DataFrame(results_log)
+# --- 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.
+        """
+    )
 
-        # 4. Prepare Submission 
-        submission_data = {"username": username.strip(), "agent_code": agent_code, "answers": answers_payload}
-        status_update = f"Agent finished. Submitting {len(answers_payload)} answers for user '{username}'..."
-        print(status_update)
+    gr.LoginButton()
 
-        # 5. Submit
-        print(f"Submitting {len(answers_payload)} answers to: {submit_url}")
-        try:
-            response = requests.post(submit_url, json=submission_data, timeout=60)
-            response.raise_for_status()
-            result_data = response.json()
-            final_status = (
-                f"Submission Successful!\n"
-                f"User: {result_data.get('username')}\n"
-                f"Overall Score: {result_data.get('score', 'N/A')}% "
-                f"({result_data.get('correct_count', '?')}/{result_data.get('total_attempted', '?')} correct)\n"
-                f"Message: {result_data.get('message', 'No message received.')}"
-            )
-            print("Submission successful.")
-            results_df = pd.DataFrame(results_log)
-            return final_status, results_df
-        except requests.exceptions.HTTPError as e:
-            error_detail = f"Server responded with status {e.response.status_code}."
-            try:
-                error_json = e.response.json()
-                error_detail += f" Detail: {error_json.get('detail', e.response.text)}"
-            except requests.exceptions.JSONDecodeError:
-                error_detail += f" Response: {e.response.text[:500]}"
-            status_message = f"Submission Failed: {error_detail}"
-            print(status_message)
-            results_df = pd.DataFrame(results_log)
-            return status_message, results_df
-        except requests.exceptions.Timeout:
-            status_message = "Submission Failed: The request timed out."
-            print(status_message)
-            results_df = pd.DataFrame(results_log)
-            return status_message, results_df
-        except requests.exceptions.RequestException as e:
-            status_message = f"Submission Failed: Network error - {e}"
-            print(status_message)
-            results_df = pd.DataFrame(results_log)
-            return status_message, results_df
-        except Exception as e:
-            status_message = f"An unexpected error occurred during submission: {e}"
-            print(status_message)
-            results_df = pd.DataFrame(results_log)
-            return status_message, results_df
-    except Exception as e:
-        error_msg = f"Critical error in run_and_submit_all: {str(e)}"
-        print(error_msg)
-        return error_msg, None
+    run_button = gr.Button("Run Evaluation & Submit All Answers")
 
-# --- Simple Command Line Interface (bypasses HTTP issues) ---
-def run_cli_interface():
-    """Run a simple command-line interface to test the agent."""
-    print("=" * 60)
-    print("ADVANCED AGENT EVALUATION - COMMAND LINE INTERFACE")
-    print("=" * 60)
-    print()
-    
-    # Get username
-    username = input("Enter your Hugging Face username: ").strip()
-    if not username:
-        print("Username is required. Exiting.")
-        return
-    
-    print(f"\nUsing username: {username}")
-    print("Starting evaluation...")
-    print("-" * 40)
-    
-    # Create mock profile
-    class MockProfile:
-        def __init__(self, username):
-            self.username = username
-    
-    profile = MockProfile(username)
-    
-    # Run evaluation
-    try:
-        status, results_df = run_and_submit_all(profile)
-        print("\n" + "=" * 60)
-        print("EVALUATION RESULTS")
-        print("=" * 60)
-        print(status)
-        
-        if results_df is not None and not results_df.empty:
-            print(f"\nProcessed {len(results_df)} questions:")
-            print(results_df.to_string(index=False))
-        else:
-            print("\nNo results to display.")
-            
-    except Exception as e:
-        print(f"\nError during evaluation: {e}")
-        import traceback
-        traceback.print_exc()
+    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)
 
-# --- Ultra-Minimal Web Interface (fallback only) ---
-def create_minimal_interface():
-    """Create an ultra-minimal interface that might work around HTTP issues."""
-    
-    def simple_evaluation(username):
-        """Simplified evaluation function."""
-        if not username or username.strip() == "":
-            return "Please enter your Hugging Face username.", None
-        
-        # Create a mock profile object
-        class MockProfile:
-            def __init__(self, username):
-                self.username = username
-        
-        profile = MockProfile(username.strip())
-        return run_and_submit_all(profile)
-    
-    # Ultra-minimal interface with minimal components
-    interface = gr.Interface(
-        fn=simple_evaluation,
-        inputs=gr.Textbox(label="Username", placeholder="your_username"),
-        outputs=[
-            gr.Textbox(label="Status"),
-            gr.DataFrame()
-        ],
-        title="Agent Evaluation",
-        description="Enter username and click Submit. Use CLI mode if you get HTTP errors.",
-        flagging_mode="never"
-    )
-    
-    return interface
-
-# --- Build Gradio Interface using Interface (minimal working version) ---
-def create_interface():
-    """Create a minimal working Gradio interface."""
-    
-    def run_evaluation(username):
-        """Wrapper function for the evaluation."""
-        if not username or username.strip() == "":
-            return "Please enter your Hugging Face username.", None
-        
-        # Create a mock profile object
-        class MockProfile:
-            def __init__(self, username):
-                self.username = username
-        
-        profile = MockProfile(username.strip())
-        return run_and_submit_all(profile)
-    
-    # Create a simple interface without LoginButton
-    interface = gr.Interface(
-        fn=run_evaluation,
-        inputs=gr.Textbox(label="Enter your Hugging Face username", placeholder="your_username"),
-        outputs=[
-            gr.Textbox(label="Status", lines=5),
-            gr.DataFrame(label="Results")
-        ],
-        title="Advanced Agent Evaluation Runner",
-        description="""
-        **Instructions:**
-        1. Enter your Hugging Face username in the text box below.
-        2. Click 'Submit' to fetch questions, run your agent, and submit answers.
-        
-        **Note:** This will take some time as the agent processes all questions.
-        """,
-        flagging_mode="never"
+    run_button.click(
+        fn=run_and_submit_all,
+        outputs=[status_output, results_table]
     )
-    
-    return interface
-
-# Create the interface - try minimal first
-demo = create_minimal_interface()
 
 if __name__ == "__main__":
     print("\n" + "-"*30 + " App Starting " + "-"*30)
@@ -365,25 +233,5 @@ if __name__ == "__main__":
 
     print("-"*(60 + len(" App Starting ")) + "\n")
 
-    # Check if we should run CLI mode (recommended)
-    import sys
-    if len(sys.argv) > 1 and sys.argv[1] == "--cli":
-        print("Running in CLI mode...")
-        run_cli_interface()
-    else:
-        print("⚠️  IMPORTANT: Hugging Face Spaces may have HTTP protocol errors.")
-        print("💡 RECOMMENDED: Use CLI mode for reliable operation:")
-        print("   python app.py --cli")
-        print()
-        print("Launching minimal web interface...")
-        print("If you encounter HTTP errors, please use the CLI mode instead.")
-        
-        # Ultra-minimal launch configuration
-        try:
-            demo.launch(server_name="0.0.0.0", server_port=7860, share=False)
-        except Exception as e:
-            print(f"❌ Web interface failed to launch: {e}")
-            print("💡 Please use CLI mode instead: python app.py --cli")
-            print("Starting CLI mode automatically...")
-            run_cli_interface()
-    
+    print("Launching Gradio Interface for Basic Agent Evaluation...")
+    demo.launch(debug=True, share=True)