feat: enhance BasicAgent to handle file inputs and improve question processing

app.py

@@ -1,34 +1,117 @@
 import os
 import gradio as gr
 import requests
-import inspect
+import inspect # Keep if you plan to use it for agent introspection later
 import pandas as pd
 
-# (Keep Constants as is)
+from src.file_processing_tool import FileIdentifier
+from src.speech_to_text import transcribe_audio
+from src.download_utils import download_file
+
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
+DOWNLOADED_FILES_DIR = "downloaded_task_files" # Directory to store downloaded files
+# Ensure the directory for downloaded files exists when the app starts
+os.makedirs(DOWNLOADED_FILES_DIR, exist_ok=True)
 
 # --- Basic Agent Definition ---
-# ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
+# ----- THIS IS WHERE YOU CAN BUILD WHAT YOU WANT ------
 class BasicAgent:
     def __init__(self):
         print("BasicAgent initialized.")
-    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
+        self.file_identifier = FileIdentifier()
+        # You might initialize other tools here if needed (e.g., spreadsheet parser, OCR)
+
+    def __call__(self, question_data: dict) -> str:
+        question_text = question_data.get("question")
+        file_url = question_data.get("file_url")
+        task_id = question_data.get("task_id", "unknown_task") # For unique file naming
+
+        print(f"Agent received task_id: {task_id}, question: {question_text}, file_url: {file_url}")
+        downloaded_file_path = None
+
+        if file_url:
+            print(f"File URL provided: {file_url}")
+            # Construct a unique filename
+            original_filename = file_url.split('/')[-1] if file_url else "file"
+            # Basic sanitization for filename
+            safe_original_filename = "".join(c for c in original_filename if c.isalnum() or c in ['.', '_', '-']).strip()
+            if not safe_original_filename:  # Handle cases where sanitization leaves an empty string
+                safe_original_filename = "downloaded_file"
+            
+            unique_filename = f"{task_id}_{safe_original_filename}"
+            
+            downloaded_file_path = download_file(file_url, DOWNLOADED_FILES_DIR, filename=unique_filename)
+
+            if not downloaded_file_path:
+                print(f"Error: Failed to download the associated file for task {task_id} from {file_url}.")
+                return "Error: Failed to download the associated file."
+            
+            print(f"File downloaded to: {downloaded_file_path}")
+            file_info = self.file_identifier.identify_file(downloaded_file_path)
+            print(f"File info for {downloaded_file_path}: {file_info}")
+
+            if file_info.get("error"):
+                return f"Error processing file: {file_info['error']}"
 
-def run_and_submit_all( profile: gr.OAuthProfile | None):
+            if file_info["determined_type"] == "audio" and file_info["suggested_action"] == "speech-to-text":
+                print(f"File {downloaded_file_path} identified as audio, attempting transcription...")
+                transcribed_text = transcribe_audio(downloaded_file_path)
+                
+                if "Error during transcription" in transcribed_text: # Basic error check
+                    print(f"Transcription error for {downloaded_file_path}: {transcribed_text}")
+                    return f"Could not transcribe audio: {transcribed_text}"
+                
+                # Placeholder: Use the question and transcribed_text to form an answer
+                # In a real agent, you'd use an LLM or other logic here.
+                answer = f"The audio file says: {transcribed_text[:200]}... (This is a placeholder answer based on transcription)"
+                print(f"Returning answer based on audio: {answer}")
+                return answer
+            
+            # Add more conditions for other file types and actions
+            # elif file_info["determined_type"] == "spreadsheet":
+            #     # Call your spreadsheet parser
+            #     # data = self.spreadsheet_parser.parse(downloaded_file_path)
+            #     # answer = self.reason_about_spreadsheet(question_text, data)
+            #     # return answer
+            #     pass
+            # elif file_info["determined_type"] == "image":
+            #     # Call your OCR/vision tool
+            #     # details = self.ocr_tool.analyze(downloaded_file_path)
+            #     # answer = self.reason_about_image(question_text, details)
+            #     # return answer
+            #     pass
+            else:
+                warning_msg = f"File type '{file_info['determined_type']}' (action: '{file_info['suggested_action']}') not yet handled for file: {os.path.basename(downloaded_file_path)}."
+                print(warning_msg)
+                # Fallback if file type is known but not handled, or if it's an unknown type
+                # You might still try to answer the question if it doesn't strictly depend on the file content.
+                return f"File received, but type '{file_info['determined_type']}' is not yet processed by this agent. Question: {question_text}"
+
+
+        # Fallback or question-only processing (if no file_url or file not handled)
+        # This is where you'd put logic for questions that don't involve files,
+        # or if a file was present but not processable by the current tools.
+        # For GAIA, many questions will have files.
+        if question_text:
+             # Placeholder for LLM call or other reasoning for text-only questions
+            default_answer = f"Received question: '{question_text}'. No specific file action taken or file not processable. (Default Response)"
+            print(f"Agent returning default text-based answer: {default_answer}")
+            return default_answer
+        else:
+            # Should not happen if GAIA questions always have text or file
+            return "No question text provided and no file processed."
+
+
+def run_and_submit_all(profile: gr.OAuthProfile | None):
     """
     Fetches all questions, runs the BasicAgent on them, submits all answers,
     and displays the results.
     """
-    # --- Determine HF Space Runtime URL and Repo URL ---
-    space_id = os.getenv("SPACE_ID") # Get the SPACE_ID for sending link to the code
+    space_id = os.getenv("SPACE_ID")
 
     if profile:
-        username= f"{profile.username}"
+        username = f"{profile.username}"
         print(f"User logged in: {username}")
     else:
         print("User not logged in.")
@@ -38,65 +121,78 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
     questions_url = f"{api_url}/questions"
     submit_url = f"{api_url}/submit"
 
-    # 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)
+    
+    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main" if space_id else "local_run_no_space_id"
+    print(f"Agent code reference: {agent_code}")
 
-    # 2. Fetch Questions
     print(f"Fetching questions from: {questions_url}")
     try:
-        response = requests.get(questions_url, timeout=15)
+        response = requests.get(questions_url, timeout=30) # Increased timeout
         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("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
+        print(f"Error decoding JSON response from questions endpoint: {e}")
+        print(f"Response text (first 500 chars): {response.text[:500] if response else 'No response object'}")
+        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}")
+        question_text = item.get("question") # Can be None if file_url is primary
+        file_url = item.get("file_url")
+
+        if not task_id:
+            print(f"Skipping item with missing task_id: {item}")
             continue
+        
+        # Prepare the input for the agent's __call__ method
+        agent_input_data = {"task_id": task_id, "question": question_text, "file_url": file_url}
+
         try:
-            submitted_answer = agent(question_text)
+            submitted_answer = agent(agent_input_data)
             answers_payload.append({"task_id": task_id, "submitted_answer": submitted_answer})
-            results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": submitted_answer})
+            results_log.append({
+                "Task ID": task_id, 
+                "Question": question_text if question_text else "N/A (File-based question)", 
+                "File URL": file_url if file_url else "N/A", 
+                "Submitted Answer": submitted_answer
+            })
         except Exception as e:
-             print(f"Error running agent on task {task_id}: {e}")
-             results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": f"AGENT ERROR: {e}"})
+            print(f"Error running agent on task {task_id}: {e}")
+            results_log.append({
+                "Task ID": task_id, 
+                "Question": question_text if question_text else "N/A (File-based question)", 
+                "File URL": file_url if file_url else "N/A", 
+                "Submitted 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)
+        # Still return results_log if it has entries (e.g. all agent errors)
+        results_df = pd.DataFrame(results_log) if results_log else None
+        return "Agent did not produce any answers to submit.", results_df
 
-    # 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)
@@ -118,7 +214,7 @@ def run_and_submit_all( profile: gr.OAuthProfile | 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]}"
+            error_detail += f" Response (first 500 chars): {e.response.text[:500]}"
         status_message = f"Submission Failed: {error_detail}"
         print(status_message)
         results_df = pd.DataFrame(results_log)
@@ -142,19 +238,19 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
 
 # --- Build Gradio Interface using Blocks ---
 with gr.Blocks() as demo:
-    gr.Markdown("# Basic Agent Evaluation Runner")
+    gr.Markdown("# GAIA Benchmark Agent 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 ...
+        1.  Clone this space, then modify `src/` files (especially `BasicAgent` in `app.py`, and tool implementations) to define your agent's logic.
         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.
+        **Notes:**
+        - The agent's processing can take time, especially with file downloads and model inferences.
+        - This is a basic framework. For more complex agents, consider asynchronous operations, caching, and more robust error handling.
         """
     )
 
@@ -163,34 +259,36 @@ with gr.Blocks() as demo:
     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)
+    results_table = gr.DataFrame(label="Questions and Agent Answers", wrap=True, interactive=False) # Set interactive=False for display
 
     run_button.click(
         fn=run_and_submit_all,
+        inputs=None, # LoginButton provides profile implicitly if used as input, but here it's handled by checking profile in the function
         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
+    space_id_startup = os.getenv("SPACE_ID")
 
     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?).")
+        print("ℹ️  SPACE_HOST environment variable not found (likely running locally).")
 
-    if space_id_startup: # Print repo URLs if SPACE_ID is found
+    if space_id_startup:
         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("ℹ️  SPACE_ID environment variable not found (likely 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)
+    print("Launching Gradio Interface for GAIA Agent Evaluation...")
+    # Set server_name and server_port for local development if needed, e.g. demo.launch(server_name="0.0.0.0", server_port=7860)
+    # For Hugging Face Spaces, share=True is often handled by the platform.
+    # debug=True is useful for development.
+    demo.launch(debug=True)