added local files, temporarely

.gitignore

@@ -1 +1,2 @@
-**/__pycache__/
+**/__pycache__/
+validation/

agents.py

@@ -1,21 +1,43 @@
 
 
+# --- Base Agent with file support ---
+class FileAwareAgent:
+    """
+    Minimal base that accepts a question and an optional file_path.
+    Subclasses can override `answer` to implement custom logic.
+    """
+
+    def __call__(self, question: str, file_path: str | None = None) -> str:
+        preview = question[:50] if isinstance(question, str) else str(question)[:50]
+        print(f"Agent received question (first 50 chars): {preview}...")
+        if file_path:
+            print(f"Agent received file_path: {file_path}")
+        fixed_answer = self.answer(question, file_path)
+        print(f"Agent returning answer: {fixed_answer}")
+        return fixed_answer
+
+    def answer(self, question: str, file_path: str | None = None) -> str:
+        raise NotImplementedError
+
+
 # --- Basic Agent Definition ---
-class BasicAgent:
+class BasicAgent(FileAwareAgent):
     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
-    
 
-class LangAgent:
+    def answer(self, question: str, file_path: str | None = None) -> str:
+        # Placeholder logic; replace with real solution strategy.
+        return "This is a default answer."
+
+
+class LangAgent(FileAwareAgent):
     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
+        print("LangAgent initialized.")
+
+    def answer(self, question: str, file_path: str | None = None) -> str:
+        # Placeholder logic; replace with language-model-based solution.
+        if file_path:
+            # Keep the intent (point to the file) but fix formatting.
+            return f"To answer this question I should read this file: {file_path}"
+        else:
+            return "This is a default answer."

app.py

@@ -1,185 +1,189 @@
 import os
 import gradio as gr
 import requests
-import inspect
 import pandas as pd
-from agents import BasicAgent
+from agents import LangAgent
 
 # (Keep Constants as is)
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
 
-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
-
-    if profile:
-        username= f"{profile.username}"
-        print(f"User logged in: {username}")
-    else:
+def resolve_user(profile: gr.OAuthProfile | None):
+    if not profile:
         print("User not logged in.")
-        return "Please Login to Hugging Face with the button.", None
+        return None, "Please Login to Hugging Face with the button."
+    username = f"{profile.username}"
+    print(f"User logged in: {username}")
+    return username, None
 
-    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)
+def build_agent():
     try:
-        agent = BasicAgent()
+        return LangAgent(), None
     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)
+        return None, f"Error initializing agent: {e}"
+
+
+def build_agent_code(space_id: str | None):
+    return f"https://huggingface.co/spaces/{space_id}/tree/main"
+
 
-    # 2. Fetch Questions
+def fetch_questions(questions_url: str):
     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("Fetched questions list is empty.")
+            return None, "Fetched questions list is empty or invalid format."
         print(f"Fetched {len(questions_data)} questions.")
-        # Log a quick overview so we can debug availability, especially file_name fields.
-        with_file = [q for q in questions_data if q.get("file_name")]
-        without_file = len(questions_data) - len(with_file)
-        print(f"Questions with file_name set: {len(with_file)}; without: {without_file}")
-        for q in with_file:
-            print(f"Task {q.get('task_id')} expects file: {q.get('file_name')}")
-        # Probe file availability so we can see what the backend returns.
-        for q in with_file:
-            task_id = q.get("task_id")
-            file_url = f"{api_url}/files/{task_id}"
-            try:
-                probe = requests.get(file_url, timeout=15)
-                print(
-                    f"Attempted access to resource at {file_url} -> "
-                    f"status {probe.status_code}, "
-                    f"content-type {probe.headers.get('content-type')}, "
-                    f"bytes {len(probe.content)}"
-                )
-            except Exception as e:
-                print(f"Attempted access to resource at {file_url} -> error: {e}")
+        return questions_data, None
+    except requests.exceptions.RequestException as e:
+        print(f"Error fetching questions: {e}")
+        return None, f"Error fetching questions: {e}"
+    except requests.exceptions.JSONDecodeError as e:
+        print(f"Error decoding JSON response from questions endpoint: {e}")
+        return None, f"Error decoding server response for questions: {e}"
+    except Exception as e:
+        print(f"An unexpected error occurred fetching questions: {e}")
+        return None, f"An unexpected error occurred fetching questions: {e}"
 
-        # Try fetching the same files from the official GAIA dataset using the HF token.
-        gaia_repo = "gaia-benchmark/GAIA"
-        gaia_files_cache = None
+
+def log_backend_file_status(with_file, total_count: int, api_url: str):
+    without_file = total_count - len(with_file)
+    print(f"Questions with file_name set: {len(with_file)}; without: {without_file}")
+    for q in with_file:
+        print(f"Task {q.get('task_id')} expects file: {q.get('file_name')}")
+    for q in with_file:
+        task_id = q.get("task_id")
+        file_url = f"{api_url}/files/{task_id}"
         try:
-            from huggingface_hub import list_repo_files, hf_hub_download
+            probe = requests.get(file_url, timeout=15)
+            print(
+                f"Attempted access to resource at {file_url} -> "
+                f"status {probe.status_code}, "
+                f"content-type {probe.headers.get('content-type')}, "
+                f"bytes {len(probe.content)}"
+            )
         except Exception as e:
-            print(f"Skipping GAIA file fetch (huggingface_hub not available): {e}")
-            gaia_repo = None
+            print(f"Attempted access to resource at {file_url} -> error: {e}")
+
+
+def get_hf_token(profile: gr.OAuthProfile | None):
+    token = None
+    if profile:
+        for attr in ("access_token", "token"):
+            token = getattr(profile, attr, None)
+            if token:
+                print(f"Using token from profile.{attr}")
+                break
+        if not token:
+            for attr in ("tokens", "auth"):
+                container = getattr(profile, attr, None)
+                if isinstance(container, dict):
+                    token = container.get("access_token") or container.get("token")
+                    if token:
+                        print(f"Using token from profile.{attr}")
+                        break
+    if not token:
+        token = (
+            os.getenv("HF_TOKEN")
+            or os.getenv("HUGGINGFACEHUB_API_TOKEN")
+            or os.getenv("HUGGINGFACE_HUB_TOKEN")
+        )
+        if token:
+            print("Using token from environment.")
+    return token
+
+
+def try_fetch_from_gaia(with_file, profile: gr.OAuthProfile | None):
+    gaia_repo = "gaia-benchmark/GAIA"
+    try:
+        from huggingface_hub import list_repo_files, hf_hub_download
+    except Exception as e:
+        print(f"Skipping GAIA file fetch (huggingface_hub not available): {e}")
+        return
+
+    token = get_hf_token(profile)
+    if not token:
+        print("Skipping GAIA file fetch (no HF toLangAgentken found in profile or env).")
+        return
 
-        if gaia_repo:
-            # Inspect profile to locate token; also allow env var fallbacks.
+    gaia_files_cache = None
+    for q in with_file:
+        fname = q.get("file_name")
+        task_id = q.get("task_id")
+        if gaia_files_cache is None:
             try:
-                print("Profile keys:", list(profile.__dict__.keys()))
+                gaia_files_cache = list_repo_files(
+                    gaia_repo, repo_type="dataset", token=token
+                )
+                print(f"GAIA repo file count: {len(gaia_files_cache)}")
             except Exception as e:
-                print(f"Could not introspect profile: {e}")
-
-            token = None
-            for attr in ("access_token", "token"):
-                token = getattr(profile, attr, None)
-                if token:
-                    print(f"Using token from profile.{attr}")
-                    break
-            if not token:
-                # Some OAuth profiles keep tokens under .tokens or .auth
-                for attr in ("tokens", "auth"):
-                    container = getattr(profile, attr, None)
-                    if isinstance(container, dict):
-                        token = container.get("access_token") or container.get("token")
-                        if token:
-                            print(f"Using token from profile.{attr}")
-                            break
-            if not token:
-                token = os.getenv("HF_TOKEN") or os.getenv("HUGGINGFACEHUB_API_TOKEN") or os.getenv("HUGGINGFACE_HUB_TOKEN")
-                if token:
-                    print("Using token from environment.")
-
-            if not token:
-                print("Skipping GAIA file fetch (no HF token found in profile or env).")
-            else:
-                for q in with_file:
-                    fname = q.get("file_name")
-                    task_id = q.get("task_id")
-                    if gaia_files_cache is None:
-                        try:
-                            gaia_files_cache = list_repo_files(
-                                gaia_repo, repo_type="dataset", token=token
-                            )
-                            print(f"GAIA repo file count: {len(gaia_files_cache)}")
-                        except Exception as e:
-                            print(f"Failed to list GAIA repo files: {e}")
-                            gaia_files_cache = []
-                    matches = []
-                    if gaia_files_cache:
-                        # First try an exact filename match, then any path containing the task_id.
-                        matches = [p for p in gaia_files_cache if p.endswith(fname)]
-                        if not matches:
-                            matches = [p for p in gaia_files_cache if task_id in p]
-                    if not matches:
-                        print(f"GAIA file not found for task {task_id} (looking for {fname}).")
-                        continue
-                    match_path = matches[0]
-                    try:
-                        local_path = hf_hub_download(
-                            gaia_repo,
-                            match_path,
-                            repo_type="dataset",
-                            token=token,
-                        )
-                        print(f"Downloaded GAIA file for task {task_id} to {local_path}")
-                    except Exception as e:
-                        print(f"Failed to download GAIA file for task {task_id} ({match_path}): {e}")
-    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
+                print(f"Failed to list GAIA repo files: {e}")
+                gaia_files_cache = []
+        matches = []
+        if gaia_files_cache:
+            matches = [p for p in gaia_files_cache if p.endswith(fname)]
+            if not matches:
+                matches = [p for p in gaia_files_cache if task_id in p]
+        if not matches:
+            print(f"GAIA file not found for task {task_id} (looking for {fname}).")
+            continue
+        match_path = matches[0]
+        try:
+            local_path = hf_hub_download(
+                gaia_repo,
+                match_path,
+                repo_type="dataset",
+                token=token,
+            )
+            print(f"Downloaded GAIA file for task {task_id} to {local_path}")
+        except Exception as e:
+            print(f"Failed to download GAIA file for task {task_id} ({match_path}): {e}")
+
 
-    # 3. Run your Agent
+def resolve_local_file(file_name: str | None):
+    if not file_name:
+        return None
+    candidate = os.path.join("validation", file_name)
+    if os.path.exists(candidate):
+        print(f"Local file found: {candidate}")
+        return candidate
+    print(f"No local file found (expected {candidate})")
+    return None
+
+
+def run_agent_on_questions(agent, questions_data):
     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")
+        file_name = item.get("file_name")
+        file_path = resolve_local_file(file_name)
         if not task_id or question_text is None:
             print(f"Skipping item with missing task_id or question: {item}")
             continue
         try:
-            submitted_answer = agent(question_text)
+            submitted_answer = agent(question_text, file_path=file_path)
             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})
         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, "Submitted Answer": f"AGENT ERROR: {e}"})
+    return answers_payload, results_log
 
-    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 
+def submit_answers(submit_url: str, username: str, agent_code: str, answers_payload, results_log):
     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)
@@ -223,6 +227,42 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
         return status_message, results_df
 
 
+def run_and_submit_all(profile: gr.OAuthProfile | None):
+    """
+    Fetch questions, run the agent, and submit answers.
+    """
+    space_id = os.getenv("SPACE_ID")
+    api_url = DEFAULT_API_URL
+    questions_url = f"{api_url}/questions"
+    submit_url = f"{api_url}/submit"
+
+    username, user_error = resolve_user(profile)
+    if user_error:
+        return user_error, None
+
+    agent, agent_error = build_agent()
+    if agent_error:
+        return agent_error, None
+
+    agent_code = build_agent_code(space_id)
+    print(agent_code)
+
+    questions_data, fetch_error = fetch_questions(questions_url)
+    if fetch_error:
+        return fetch_error, None
+
+    with_file = [q for q in questions_data if q.get("file_name")]
+    log_backend_file_status(with_file, len(questions_data), api_url)
+    try_fetch_from_gaia(with_file, profile)
+
+    answers_payload, results_log = run_agent_on_questions(agent, questions_data)
+    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)
+
+    return submit_answers(submit_url, username, agent_code, answers_payload, results_log)
+
+
 # --- Build Gradio Interface using Blocks ---
 with gr.Blocks() as demo:
     gr.Markdown("# Basic Agent Evaluation Runner")