update (app.py, graph.py, tools.py) : ajout récup des fichiers questions, et gestion du graph et des outils + premier test run (3 bonnes réponses)

.gitignore

@@ -1,5 +1,9 @@
 .devcontainer/
 .devcontainer/*
+data/
 .env
 requirements.local.txt
-README.local.md
+README.local.md
+*ipynb
+*.json
+*.csv

app.py

@@ -1,35 +1,81 @@
 import os
+import json
+from pathlib import Path
+
 import gradio as gr
 import requests
-import inspect
 import pandas as pd
-import json
+from langchain_core.messages import HumanMessage
+
+from load_data import (
+    ensure_validation_data,
+    get_file_from_gaia_level1_data,
+    get_question,
+)
+from graph import react_graph
+
 
 # (Keep Constants as is)
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
+
 # --- 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:
         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
 
-def run_and_submit_all( profile: gr.OAuthProfile | None):
+
+def _invoke_react_graph(task_id: str) -> str:
+    """
+    Invokes the react graph with the given task_id and returns the final answer.
+    """
+    input_file = get_file_from_gaia_level1_data(task_id)
+    question = get_question(task_id)
+    print(
+        f"Invoking react graph for task_id={task_id} with question: {question[:50]}... and input_file: {input_file}"
+    )
+
+    messages = [HumanMessage(content=question)]
+
+    messages = react_graph.invoke(
+        {"messages": messages, "input_file": input_file},
+        config={"recursion_limit": 50},
+    )
+
+    final_message = messages["messages"][-1]
+    print(f"Final message from react graph: {final_message.content[:100]}...")
+
+    # Extract the final answer from the message content
+    final_answer_prefix = "FINAL ANSWER:"
+    if final_answer_prefix in final_message.content:
+        final_answer = final_message.content.split(final_answer_prefix)[-1].strip()
+        print(f"Extracted final answer: {final_answer}")
+        return final_answer
+    else:
+        print(
+            f"Warning: 'FINAL ANSWER:' prefix not found in react graph output. Returning full message content as answer."
+        )
+        return final_message.content.strip()
+
+
+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")  # Get the SPACE_ID for sending link to the code
 
     if profile:
-        username= f"{profile.username}"
+        username = f"{profile.username}"
         print(f"User logged in: {username}")
     else:
         print("User not logged in.")
@@ -40,33 +86,37 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
     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
+    # 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. Load Questions (cache first, API fallback)
-    cache_path = os.path.join(os.path.dirname(__file__), "cached_questions.json")
+    cache_path = Path(__file__).resolve().parent / "cached_questions.json"
     questions_data = None
 
     # 2.a Try cache first
-    if os.path.exists(cache_path):
+    if cache_path.exists():
         try:
             with open(cache_path, "r", encoding="utf-8") as f:
                 cached = json.load(f)
             if isinstance(cached, list) and cached:
                 questions_data = cached
-                print(f"Loaded {len(questions_data)} questions from cache: {cache_path}")
+                print(
+                    f"Loaded {len(questions_data)} questions from cache: {cache_path}"
+                )
             else:
                 print(f"Cache file found but empty/invalid format: {cache_path}")
         except json.JSONDecodeError as e:
             print(f"Cache JSON is invalid ({cache_path}): {e}. Falling back to API.")
         except OSError as e:
-            print(f"Could not read cache file ({cache_path}): {e}. Falling back to API.")
+            print(
+                f"Could not read cache file ({cache_path}): {e}. Falling back to API."
+            )
 
     # 2.b Fetch from API only if cache missing/invalid/empty
     if questions_data is None:
@@ -101,27 +151,41 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
             print(f"An unexpected error occurred fetching questions: {e}")
             return f"An unexpected error occurred fetching questions: {e}", None
 
+    # 2.c Retrieve the data files provided for the test ( in the case of the test on Hugging Face, the files are in data/2023_level1/validation/)
+    base_dir = Path(__file__).resolve().parent
+    ok, error_message = ensure_validation_data(base_dir)
+    if not ok:
+        return error_message, None
+
     # 3. Run your Agent (answers cache by task_id)
     results_log = []
     answers_payload = []
 
-    answers_cache_path = os.path.join(os.path.dirname(__file__), "cached_answers.json")
+    answers_cache_path = Path(__file__).resolve().parent / "cached_answers.json"
     answers_cache = {}
 
     # 3.a Load answers cache
-    if os.path.exists(answers_cache_path):
+    if answers_cache_path.exists():
         try:
             with open(answers_cache_path, "r", encoding="utf-8") as f:
                 loaded_cache = json.load(f)
             if isinstance(loaded_cache, dict):
                 answers_cache = loaded_cache
-                print(f"Loaded {len(answers_cache)} cached answers from: {answers_cache_path}")
+                print(
+                    f"Loaded {len(answers_cache)} cached answers from: {answers_cache_path}"
+                )
             else:
-                print(f"Answers cache has invalid format (expected object): {answers_cache_path}")
+                print(
+                    f"Answers cache has invalid format (expected object): {answers_cache_path}"
+                )
         except json.JSONDecodeError as e:
-            print(f"Answers cache JSON is invalid ({answers_cache_path}): {e}. Starting with empty cache.")
+            print(
+                f"Answers cache JSON is invalid ({answers_cache_path}): {e}. Starting with empty cache."
+            )
         except OSError as e:
-            print(f"Could not read answers cache ({answers_cache_path}): {e}. Starting with empty cache.")
+            print(
+                f"Could not read answers cache ({answers_cache_path}): {e}. Starting with empty cache."
+            )
 
     cache_updated = False
 
@@ -142,18 +206,31 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
             print(f"Using cached answer for task_id={task_id}")
         else:
             try:
-                submitted_answer = agent(question_text)
+                submitted_answer = _invoke_react_graph(task_key)
                 answers_cache[task_key] = submitted_answer
                 cache_updated = True
                 print(f"Computed and cached answer for task_id={task_id}")
             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}"})
+                    {
+                        "Task ID": task_id,
+                        "Question": question_text,
+                        "Submitted Answer": f"AGENT ERROR: {e}",
+                    }
+                )
                 continue
 
-        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})
+        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,
+            }
+        )
 
     # 3.b Save answers cache only if updated
     if cache_updated:
@@ -168,8 +245,12 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
         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}
+    # 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)
 
@@ -239,20 +320,19 @@ 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)
+    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]
-    )
+    run_button.click(fn=run_and_submit_all, outputs=[status_output, results_table])
 
 if __name__ == "__main__":
-    print("\n" + "-"*30 + " App Starting " + "-"*30)
+    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")  # Get SPACE_ID at startup
 
     if space_host_startup:
         print(f"✅ SPACE_HOST found: {space_host_startup}")
@@ -260,14 +340,18 @@ if __name__ == "__main__":
     else:
         print("ℹ️  SPACE_HOST environment variable not found (running locally?).")
 
-    if space_id_startup: # Print repo URLs if SPACE_ID is found
+    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")
+        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 (running locally?). Repo URL cannot be determined."
+        )
 
-    print("-"*(60 + len(" App Starting ")) + "\n")
+    print("-" * (60 + len(" App Starting ")) + "\n")
 
     print("Launching Gradio Interface for Basic Agent Evaluation...")
-    demo.launch(debug=True, share=False)
+    demo.launch(debug=True, share=False)

cached_answers.json

@@ -1,22 +1,20 @@
 {
-  "8e867cd7-cff9-4e6c-867a-ff5ddc2550be": "This is a default answer.",
-  "a1e91b78-d3d8-4675-bb8d-62741b4b68a6": "This is a default answer.",
-  "2d83110e-a098-4ebb-9987-066c06fa42d0": "This is a default answer.",
-  "cca530fc-4052-43b2-b130-b30968d8aa44": "This is a default answer.",
-  "4fc2f1ae-8625-45b5-ab34-ad4433bc21f8": "This is a default answer.",
-  "6f37996b-2ac7-44b0-8e68-6d28256631b4": "This is a default answer.",
-  "9d191bce-651d-4746-be2d-7ef8ecadb9c2": "This is a default answer.",
-  "cabe07ed-9eca-40ea-8ead-410ef5e83f91": "This is a default answer.",
-  "3cef3a44-215e-4aed-8e3b-b1e3f08063b7": "This is a default answer.",
-  "99c9cc74-fdc8-46c6-8f8d-3ce2d3bfeea3": "This is a default answer.",
-  "305ac316-eef6-4446-960a-92d80d542f82": "This is a default answer.",
-  "f918266a-b3e0-4914-865d-4faa564f1aef": "This is a default answer.",
-  "3f57289b-8c60-48be-bd80-01f8099ca449": "This is a default answer.",
-  "1f975693-876d-457b-a649-393859e79bf3": "This is a default answer.",
-  "840bfca7-4f7b-481a-8794-c560c340185d": "This is a default answer.",
-  "bda648d7-d618-4883-88f4-3466eabd860e": "This is a default answer.",
-  "cf106601-ab4f-4af9-b045-5295fe67b37d": "This is a default answer.",
-  "a0c07678-e491-4bbc-8f0b-07405144218f": "This is a default answer.",
-  "7bd855d8-463d-4ed5-93ca-5fe35145f733": "This is a default answer.",
-  "5a0c1adf-205e-4841-a666-7c3ef95def9d": "This is a default answer."
+  "8e867cd7-cff9-4e6c-867a-ff5ddc2550be": "4",
+  "a1e91b78-d3d8-4675-bb8d-62741b4b68a6": "I cannot directly access or analyze the content of the video link provided. To determine the highest number of bird species on camera simultaneously, I would need either a description of the video content or a summary of relevant information. Alternatively, I can try to find a description or discussion about this specific video if available online. Would you like me to search for any details or summaries related to this video?",
+  "2d83110e-a098-4ebb-9987-066c06fa42d0": "The sentence written in reverse is: \".right\"",
+  "cca530fc-4052-43b2-b130-b30968d8aa44": "The image contains a chessboard with coordinates labeled from a to h horizontally and 1 to 8 vertically. To identify the best move for black, I need to analyze the position. Since I cannot see the actual pieces from the text alone, I will rely on the extracted text and the typical context of such puzzles.\n\nHowever, the image's text only shows the coordinate labels, not the pieces or their positions. To accurately determine the winning move, I need to see the actual arrangement of the pieces on the board.\n\nPlease provide a detailed description of the position or upload an image showing the pieces on the board.",
+  "6f37996b-2ac7-44b0-8e68-6d28256631b4": "b,e",
+  "9d191bce-651d-4746-be2d-7ef8ecadb9c2": "I don't have the capability to directly access or view videos, including YouTube links. However, I can help if you provide a transcript or more context about the scene. Alternatively, I can try to find a script or quote from that episode if you tell me which Stargate SG-1 episode it is from. Please specify or provide more details.",
+  "cabe07ed-9eca-40ea-8ead-410ef5e83f91": "None",
+  "3cef3a44-215e-4aed-8e3b-b1e3f08063b7": "broccoli, celery, green beans, lettuce, sweet potatoes",
+  "99c9cc74-fdc8-46c6-8f8d-3ce2d3bfeea3": "It appears I am unable to directly listen to or process audio files. However, if you can provide a transcript or the key details from the voice memo, I can help identify the ingredients for the filling. Please share any text or details you have.",
+  "305ac316-eef6-4446-960a-92d80d542f82": "Bartłomiej",
+  "f918266a-b3e0-4914-865d-4faa564f1aef": "0",
+  "3f57289b-8c60-48be-bd80-01f8099ca449": "I need to verify the player with the most walks for the Yankees in 1977. Based on the search results, Derek Jeter is a notable Yankees player, but he played in the late 1990s and 2000s, so he is unlikely to be the player with the most walks in 1977. \n\nThe search results do not clearly indicate the player with the most walks in 1977. I will now look for specific statistics for Yankees players in 1977 to identify who had the most walks and at-bats.\n\nI'll search for Yankees 1977 player stats to find the player with the most walks and then check their at-bats.",
+  "1f975693-876d-457b-a649-393859e79bf3": "It appears that I am unable to directly process audio files. However, I can guide you on how to transcribe the audio using available tools or software such as speech recognition libraries or online transcription services. Would you like me to provide a step-by-step guide on how to do this?",
+  "840bfca7-4f7b-481a-8794-c560c340185d": "",
+  "bda648d7-d618-4883-88f4-3466eabd860e": "Saint Petersburg",
+  "cf106601-ab4f-4af9-b045-5295fe67b37d": "CUB",
+  "a0c07678-e491-4bbc-8f0b-07405144218f": "Ohtani, Kondoh.",
+  "5a0c1adf-205e-4841-a666-7c3ef95def9d": "Let's analyze the question step-by-step:\n\n1. The question asks for the first name of a specific individual: the only Malko Competition recipient from the 20th century (after 1977).\n2. This individual’s nationality is from a country that no longer exists.\n3. The recipient must have received the Malko Competition award after 1977, which is in the late 20th century.\n4. The country of nationality must be a defunct country.\n\nFirst, I need to identify the recipients of the Malko Competition (also known as the Malko Competition for Young Conductors). I will search for a list of recipients and their nationalities, focusing on those after 1977.\n\nI will use the Tavily search to find relevant information about the Malko Competition winners.\n\nLet's proceed with the search.\n\ntavily_search: \"Malko Competition winners list\""
 }

graph.py

@@ -0,0 +1,98 @@
+# std lib
+import os
+
+# 3rd party imports
+from typing import TypedDict, Annotated, Optional
+from langchain_core.messages import AnyMessage, HumanMessage, SystemMessage
+from langchain_openai import ChatOpenAI
+from langgraph.graph.message import add_messages
+from langgraph.graph import START, StateGraph
+from langgraph.prebuilt import ToolNode, tools_condition
+
+# local imports
+from tools import (
+    select_tools_for_input,
+)
+
+
+openai_token = os.getenv("HF_FINAL_ASSIGNMENT_OPENAI")
+
+llm = ChatOpenAI(model="gpt-4.1-nano", api_key=openai_token, temperature=0)
+
+
+class AgentState(TypedDict):
+    # The input document
+    input_file: Optional[str]  # Contains file path, type (ANY)
+    messages: Annotated[list[AnyMessage], add_messages]
+
+
+def _selected_tools_from_state(state: AgentState):
+    return select_tools_for_input(state.get("input_file"))
+
+
+def _build_tools_description(selected_tools: list) -> str:
+    lines = []
+    for fn in selected_tools:
+        doc = (fn.__doc__ or "").strip().split("\n")[0]
+        if doc:
+            lines.append(f"- {fn.__name__}: {doc}")
+        else:
+            lines.append(f"- {fn.__name__}")
+    return "\n".join(lines)
+
+
+def assistant(state: AgentState):
+    data_file = state["input_file"]
+    selected_tools = _selected_tools_from_state(state)
+    llm_with_tools = llm.bind_tools(selected_tools, parallel_tool_calls=False)
+    tools_description = _build_tools_description(selected_tools)
+
+    sys_msg = SystemMessage(
+        content=(
+            "You are a general AI assistant. I will ask you a question. "
+            "Report your thoughts, and finish your answer with the following template: "
+            "FINAL ANSWER: [YOUR FINAL ANSWER]. YOUR FINAL ANSWER should be a number OR as few words as possible "
+            "OR a comma separated list of numbers and/or strings. If you are asked for a number, don't use comma "
+            "to write your number neither use units such as $ or percent sign unless specified otherwise. "
+            "If you are asked for a string, don't use articles, neither abbreviations (e.g. for cities), and write "
+            "the digits in plain text unless specified otherwise. If you are asked for a comma separated list, apply "
+            "the above rules depending of whether the element to be put in the list is a number or a string.\n\n"
+            f"Available tools for this input:\n{tools_description}"
+        )
+    )
+
+    prompt_messages = [sys_msg] + state["messages"]
+    if data_file:
+        prompt_messages.append(
+            HumanMessage(content=f"Input file path (local): {data_file}")
+        )
+    print("Prompt messages for assistant:")
+    for msg in prompt_messages:
+        print(f"- {msg.content}")
+
+    response = llm_with_tools.invoke(prompt_messages)
+    return {"messages": [response], "input_file": state["input_file"]}
+
+
+def tools_node(state: AgentState):
+    selected_tools = _selected_tools_from_state(state)
+    return ToolNode(selected_tools).invoke(state)
+
+
+# Graph
+builder = StateGraph(AgentState)
+
+# Define nodes: these do the work
+builder.add_node("assistant", assistant)
+builder.add_node("tools", tools_node)
+
+# Define edges: these determine how the control flow moves
+builder.add_edge(START, "assistant")
+builder.add_conditional_edges(
+    "assistant",
+    # If the latest message (result) from assistant is a tool call -> tools_condition routes to tools
+    # If the latest message (result) from assistant is a not a tool call -> tools_condition routes to END
+    tools_condition,
+)
+builder.add_edge("tools", "assistant")
+react_graph = builder.compile()

load_data.py

@@ -0,0 +1,119 @@
+# std lib
+import os
+from pathlib import Path
+
+# 3rd party imports
+import pandas as pd
+
+# local imports
+from huggingface_hub import snapshot_download
+
+DATA_DIR = Path(__file__).resolve().parent / "data"
+
+
+def get_full_gaia_level1_data():
+    """
+    Download the full GAIA level 1 data and save it locally in data/.
+    """
+    os.makedirs(DATA_DIR, exist_ok=True)
+
+    # Fallback to common HF token names; token can be optional for public datasets.
+    token = os.getenv("HF_FINAL_ASSIGNMENT_DRAFT") or os.getenv("HF_TOKEN")
+
+    kwargs = {
+        "repo_id": "gaia-benchmark/GAIA",
+        "repo_type": "dataset",
+        "local_dir": DATA_DIR,
+    }
+    if token:
+        kwargs["token"] = token
+
+    snapshot_download(**kwargs)
+
+
+def get_file_from_gaia_level1_data(task_id: str):
+    """
+    Given a GAIA level 1 task ID, return the corresponding file path in the local directory data/gaia_level1_data.
+    les fichiers servant au test HF sont dans data/gaia_level1_data/2023_level1/validation/
+    """
+    # lire le contenu du dossier data/gaia_level1_data/2023_level1/validation et afficher les chemins des fichiers présents
+    validation_dir = DATA_DIR / "2023" / "validation"
+    for root, _, files in os.walk(validation_dir):
+        for file in files:
+            if task_id in file:
+                return os.path.join(root, file)
+    return None
+
+
+def get_question(task_id: str) -> str:
+    """
+    Given a GAIA level 1 task ID, return the corresponding question.
+    """
+    metadata_file = os.path.join(
+        DATA_DIR, "2023", "validation", "metadata.level1.parquet"
+    )
+    if os.path.exists(metadata_file):
+        metadata_df = pd.read_parquet(metadata_file)
+        return metadata_df.loc[metadata_df["task_id"] == task_id, "Question"].values[0]
+    else:
+        print(f"Metadata file not found: {metadata_file}")
+        return ""
+
+
+def ensure_validation_data(base_dir: Path):
+    """
+    Ensure GAIA 2023 level1 validation files are present.
+    Returns (ok: bool, error_message: str | None).
+    """
+    validation_dir = base_dir / "data" / "2023" / "validation"
+    metadata_file = validation_dir / "metadata.level1.parquet"
+    need_download_reason = None
+
+    # Fast fail: missing or empty validation directory
+    if not validation_dir.exists() or not any(validation_dir.iterdir()):
+        need_download_reason = f"Validation data not found in {validation_dir}"
+    # Metadata is required to validate expected files
+    elif not metadata_file.exists():
+        need_download_reason = (
+            f"Metadata file not found: {metadata_file}. Cannot verify expected files"
+        )
+    else:
+        try:
+            # Read only the needed column for speed/memory
+            metadata_df = pd.read_parquet(metadata_file, columns=["file_name"])
+            expected_files = {
+                str(name) for name in metadata_df["file_name"].dropna().unique()
+            }
+
+            present_files = {p.name for p in validation_dir.iterdir() if p.is_file()}
+            missing_files = expected_files - present_files
+
+            if missing_files:
+                need_download_reason = (
+                    f"Missing {len(missing_files)} expected validation files"
+                )
+        except Exception as e:
+            need_download_reason = (
+                f"Error reading metadata ({metadata_file}): {e}. "
+                "Cannot verify expected files"
+            )
+
+    if need_download_reason is not None:
+        print(f"{need_download_reason}. Downloading full GAIA level 1 data...")
+        try:
+            get_full_gaia_level1_data()
+            print("Data download completed.")
+        except Exception as e:
+            error_message = f"Error downloading GAIA level 1 data: {e}"
+            print(error_message)
+            return False, error_message
+    else:
+        print("All expected validation files are present. Skipping data download.")
+
+    return True, None
+
+
+if __name__ == "__main__":
+    # get_full_gaia_level1_data()
+    print(get_file_from_gaia_level1_data("cca530fc-4052-43b2-b130-b30968d8aa44"))
+    # print(get_question("cca530fc-4052-43b2-b130-b30968d8aa44"))

requirements.txt

@@ -1,2 +1,11 @@
 gradio
-requests
+requests
+pandas
+pyarrow
+huggingface_hub
+langchain-core
+langchain-openai
+langgraph
+tavily-python
+wikipedia
+youtube-transcript-api

tools.py

@@ -0,0 +1,483 @@
+# std lib
+import base64
+from typing import Optional
+import os
+import requests
+from pathlib import Path
+
+# 3rd party imports
+import pandas as pd
+from langchain_core.messages import HumanMessage
+from langchain_openai import ChatOpenAI
+from tavily import TavilyClient
+import wikipedia
+from youtube_transcript_api import YouTubeTranscriptApi
+
+
+openai_token = os.getenv("HF_FINAL_ASSIGNMENT_OPENAI")
+tavily_api_key = os.getenv("HF_FINAL_ASSIGNMENT_TAVILY")
+
+tavily_client = TavilyClient(api_key=tavily_api_key)
+vision_llm = ChatOpenAI(model="gpt-5.2", api_key=openai_token, temperature=0)
+
+
+def extract_text_from_image(img_path: str) -> str:
+    """
+    Extract text from an image file using a multimodal model.
+    Use this method only for image files.
+
+    Args:
+        img_path: A local image file path (strings).
+
+    Returns:
+        A single string containing the concatenated text extracted from each image.
+    """
+    all_text = ""
+    try:
+        # Read image and encode as base64
+        with open(img_path, "rb") as image_file:
+            image_bytes = image_file.read()
+
+        image_base64 = base64.b64encode(image_bytes).decode("utf-8")
+
+        # Prepare the prompt including the base64 image data
+        message = [
+            HumanMessage(
+                content=[
+                    {
+                        "type": "text",
+                        "text": (
+                            "Extract all the text from this image. "
+                            "Return only the extracted text, no explanations."
+                        ),
+                    },
+                    {
+                        "type": "image_url",
+                        "image_url": {"url": f"data:image/png;base64,{image_base64}"},
+                    },
+                ]
+            )
+        ]
+
+        # Call the vision-capable model
+        response = vision_llm.invoke(message)
+
+        # Append extracted text
+        all_text += response.content + "\n\n"
+
+        return all_text.strip()
+    except Exception as e:
+        # You can choose whether to raise or just return an empty string / error message
+        error_msg = f"Error extracting text: {str(e)}"
+        print(error_msg)
+        return ""
+
+
+def tavily_search(query: str) -> dict:
+    """Search the web using Tavily and return a compact list of results as plain text."""
+    response = tavily_client.search(query=query, search_depth="advanced")
+    return response
+
+
+def wikipedia_get_suggested_title_for_query(query: str) -> str:
+    """Get the most relevant Wikipedia page title for a given query."""
+    try:
+        suggested_title = wikipedia.suggest(query)
+        return suggested_title if suggested_title else ""
+    except Exception as e:
+        print(f"Error getting Wikipedia suggestion: {str(e)}")
+        return ""
+
+
+def wikipedia_search_pages(query: str):
+    """
+    Search Wikipedia for a query and return a list of relevant page titles.
+    """
+    try:
+        search_results = wikipedia.search(query)
+        return "\n".join(search_results)
+    except Exception as e:
+        print(f"Error searching Wikipedia: {str(e)}")
+        return ""
+
+
+def wikipedia_get_page_summary(page_title: str, lang: str = "en") -> str:
+    """
+    Get the summary of a Wikipedia page given its title.
+    """
+    try:
+        summary = wikipedia.summary(page_title)
+        return summary
+    except Exception as e:
+        print(f"Error getting Wikipedia page summary: {str(e)}")
+        return ""
+
+
+def wikipedia_get_page_full_content(page_title: str):
+    """
+    Get the full content of a Wikipedia page given its title.
+
+    We can access most properties using property methods. Example:
+
+    ny = wikipedia.page("New York")
+
+    ny.title
+    u'New York'
+
+    ny.url
+    u'http://en.wikipedia.org/wiki/NewYork'
+
+    ny.content
+    u'New York is a state in the Northeastern region of the United States. New York is the 27th-most exten'...
+
+    ny.images[0]
+    u'http://upload.wikimedia.org/wikipedia/commons/9/91/New_York_quarter%2C_reverse_side%2C_2001.jpg'
+
+    ny.links[0]
+    u'1790 United States Census'
+
+    """
+    try:
+        page = wikipedia.page(page_title)
+        return page.content
+    except Exception as e:
+        print(f"Error getting Wikipedia page content: {str(e)}")
+        return ""
+
+
+def youtube_get_transcript_of_video(video_url: str):
+    """
+    Get the transcript of a YouTube video given its URL.
+
+    using the YouTube Data API or a third-party library
+
+    This will return a FetchedTranscript object looking somewhat like this:
+
+    FetchedTranscript(
+        snippets=[
+            FetchedTranscriptSnippet(
+                text="Hey there",
+                start=0.0,
+                duration=1.54,
+            ),
+            FetchedTranscriptSnippet(
+                text="how are you",
+                start=1.54,
+                duration=4.16,
+            ),
+            # ...
+        ],
+        video_id="12345",
+        language="English",
+        language_code="en",
+        is_generated=False,
+    )
+
+    Do NOT run: `YouTubeTranscriptApi().fetch("https://www.youtube.com/watch?v=1234")`
+    Instead run: `YouTubeTranscriptApi().fetch("1234")`
+
+    """
+    # Placeholder implementation
+    ytt_api = YouTubeTranscriptApi()
+
+    # extract video ID from URL
+    video_id = video_url.split("v=")[-1]
+    fetched_transcript = ytt_api.fetch(video_id)
+
+    return fetched_transcript
+
+
+def chessboard_image_to_text_description_to_fen_notation(
+    image_path: str, color_to_move: str
+) -> str:
+    """
+    Converts a chessboard image into a textual description of the position and its FEN notation.
+
+    Args:
+        image_path: A local image file path (string) representing the chessboard position.
+        color_to_move: A string indicating which color is to move ("white" or "black").
+
+    Returns:
+        A string indicating the FEN notation of the chess position.
+    """
+    all_text = ""
+    try:
+        # Read image and encode as base64
+        with open(image_path, "rb") as image_file:
+            image_bytes = image_file.read()
+
+        image_base64 = base64.b64encode(image_bytes).decode("utf-8")
+
+        # Prepare the prompt including the base64 image data
+        message = [
+            HumanMessage(
+                content=[
+                    {
+                        "type": "text",
+                        "text": (
+                            "Draw a 8x8 table representing the chessboard."
+                            "Describe the chess position rank by rank from rank 8 to rank 1. "
+                            "For each rank, list what occupies each square from file a to file h. "
+                            "One square at a time, complete the table with the piece occupying that square if any, or with '1' if the square is empty. "
+                            "Once the table is complete, provide a textual description of the chessboard : uppercase letters for white pieces, lowercase letters for black pieces, and '1' for empty squares. "
+                            "the values '1' in the table are helpful to determine the number of consecutive empty squares in a row, which is necessary to determine the FEN notation. "
+                            "Based on this description, determine the FEN notation of the position."
+                            "Reminder: for the FEN notation, start counting from rank 8 to rank 1, and for each rank, count from file a to file h."
+                            "And if it is white to move, the FEN notation should end with 'w', and if it is black to move, the FEN notation should end with 'b'."
+                            "Finally, the FEN notation should finish with the string '- - 0 1'"
+                        ),
+                    },
+                    {
+                        "type": "text",
+                        "text": (f"It is {color_to_move} to move in this position."),
+                    },
+                    {
+                        "type": "image_url",
+                        "image_url": {"url": f"data:image/png;base64,{image_base64}"},
+                    },
+                ]
+            )
+        ]
+
+        # Call the vision-capable model
+        response = vision_llm.invoke(message)
+
+        # Append extracted text
+        all_text += response.content + "\n\n"
+
+        print(f"Extracted table description: {all_text.strip()}")
+        return all_text.strip()
+    except Exception as e:
+        # You can choose whether to raise or just return an empty string / error message
+        error_msg = f"Error extracting text: {str(e)}"
+        print(error_msg)
+        return ""
+
+
+def chessboard_get_fen_notation(image_path: str, color_to_move: str) -> str:
+    """
+    Converts digital chessboard image into Forsyth-Edwards notation (FEN) notation
+    Args:
+     - image_path: A local image file path (string) representing the chessboard position.
+     - color_to_move: A string indicating which color is to move ("white" or "black").
+    Returns:
+    A string representing the chess position in FEN notation.
+    """
+
+    all_text = ""
+    try:
+        # Read image and encode as base64
+        with open(image_path, "rb") as image_file:
+            image_bytes = image_file.read()
+
+        image_base64 = base64.b64encode(image_bytes).decode("utf-8")
+
+        # Prepare the prompt including the base64 image data
+        message = [
+            HumanMessage(
+                content=[
+                    {
+                        "type": "text",
+                        "text": (
+                            "Describe the chess position rank by rank from rank 8 to rank 1. "
+                            "For each rank, list what occupies each square from a to h. "
+                            "Then convert your description to FEN notation."
+                            "Reminder: for the FEN notation, start counting from rank 8 to rank 1, and for each rank, count from file a to file h."
+                            "And if it is white to move, the FEN notation should end with 'w', and if it is black to move, the FEN notation should end with 'b'."
+                            "Finally, the FEN notation should finish with the string '- - 0 1'"
+                        ),
+                    },
+                    {
+                        "type": "text",
+                        "text": (f"It is {color_to_move} to move in this position."),
+                    },
+                    {
+                        "type": "image_url",
+                        "image_url": {"url": f"data:image/png;base64,{image_base64}"},
+                    },
+                ]
+            )
+        ]
+
+        # Call the vision-capable model
+        response = vision_llm.invoke(message)
+
+        # Append extracted text
+        all_text += response.content + "\n\n"
+
+        print(f"Extracted FEN notation: {all_text.strip()}")
+        return all_text.strip()
+    except Exception as e:
+        # You can choose whether to raise or just return an empty string / error message
+        error_msg = f"Error extracting text: {str(e)}"
+        print(error_msg)
+        return ""
+
+
+def get_best_next_move_from_fen(fen: str):
+    """
+    requests Lichess API to get the best next move given a chess position in FEN notation.
+    required parameters:
+    - fen: A string representing the chess position in Forsyth-Edwards Notation (FEN).
+    """
+
+    lichess_api_url = f"https://lichess.org/api/cloud-eval?fen={fen}"
+
+    try:
+        response = requests.get(lichess_api_url)
+        if response.status_code == 200:
+            data = response.json()
+            pvs = data.get(
+                "pvs", []
+            )  # list of principal variations (best move sequences)
+            if pvs and isinstance(pvs, list):
+                best_move = (
+                    pvs[0].get("moves", "").split()[0]
+                )  # Get the first move of the best sequence
+                return best_move
+        else:
+            print(f"Error fetching best move from Lichess API: {response.status_code}")
+            return ""
+    except Exception as e:
+        print(f"Exception occurred while fetching best move from Lichess API: {str(e)}")
+        return ""
+
+
+def execute_python_code_with_subprocess(code: str) -> str:
+    """
+    Executes Python code in a subprocess and returns the output as a string.
+    This can be used to execute code from the GAIA level 1 tasks in a safe environment.
+    Args:
+    - code: A string containing the Python code to execute.
+    Returns:
+    - A string containing the standard output from the executed code, or an error message if execution fails.
+    """
+    import subprocess
+    import sys
+
+    try:
+        # Run the code in a subprocess and capture the output
+        result = subprocess.run(
+            [sys.executable, "-c", code],
+            capture_output=True,
+            text=True,
+            timeout=60,  # Set a timeout to prevent hanging
+        )
+        return result.stdout.strip()
+    except subprocess.TimeoutExpired:
+        return "Error: Code execution timed out."
+    except Exception as e:
+        return f"Error executing code: {str(e)}"
+
+
+def transcribe_audio_file(audio_file_path: str) -> str:
+    """
+    Transcribes an audio file to text using OpenAI's gpt-4o-transcribe model.
+    Args:
+    - audio_file_path: A string representing the local path to the audio file.
+    Returns:
+    - A string containing the transcribed text from the audio file, or an error message if transcription fails.
+    """
+    from openai import OpenAI
+
+    client = OpenAI(api_key=openai_token)
+
+    try:
+        with open(audio_file_path, "rb") as audio_file:
+            transcript = client.audio.transcriptions.create(
+                model="gpt-4o-transcribe", file=audio_file, response_format="text"
+            )
+        return transcript.strip()
+    except Exception as e:
+        return f"Error transcribing audio: {str(e)}"
+
+
+def read_excel_file(file_path: str) -> str:
+    """
+    Reads an Excel file and returns its content as a string.
+    Args:
+    - file_path: A string representing the local path to the Excel file.
+    Returns:
+    - A string containing the content of the Excel file, or an error message if reading fails.
+    """
+    try:
+        df = pd.read_excel(file_path)
+        print(f"Excel file read successfully. DataFrame shape: {df.head()}")
+        return df.to_string(index=False)
+    except Exception as e:
+        return f"Error reading Excel file: {str(e)}"
+
+
+def divide(a: float, b: float) -> float:
+    """Divide a and b."""
+    return a / b
+
+
+def multiply(a: float, b: float) -> float:
+    """Multiply a and b."""
+    return a * b
+
+
+def add(a: float, b: float) -> float:
+    """Add a and b."""
+    return a + b
+
+
+def subtract(a: float, b: float) -> float:
+    """Subtract b from a."""
+    return a - b
+
+
+tools = [
+    extract_text_from_image,
+    divide,
+    multiply,
+    add,
+    subtract,
+    tavily_search,
+    wikipedia_get_suggested_title_for_query,
+    wikipedia_search_pages,
+    wikipedia_get_page_summary,
+    wikipedia_get_page_full_content,
+    youtube_get_transcript_of_video,
+    # chessboard_get_fen_notation,
+    get_best_next_move_from_fen,
+    chessboard_image_to_text_description_to_fen_notation,
+    execute_python_code_with_subprocess,
+    transcribe_audio_file,
+    read_excel_file,
+]
+
+
+def select_tools_for_input(input_file: Optional[str]):
+    suffix = Path(input_file).suffix.lower() if input_file else ""
+
+    # Cas tableur
+    if suffix in [".xls", ".xlsx"]:
+        print("Selecting tools for Excel file input.")
+        return [
+            read_excel_file,
+            execute_python_code_with_subprocess,
+            add,
+            subtract,
+            multiply,
+            divide,
+        ]
+
+    # Cas image
+    if suffix in [".png", ".jpg", ".jpeg", ".webp", ".bmp", ".gif"]:
+        return [extract_text_from_image]
+
+    # Fallback général
+    return [
+        tavily_search,
+        wikipedia_get_suggested_title_for_query,
+        wikipedia_search_pages,
+        wikipedia_get_page_summary,
+        wikipedia_get_page_full_content,
+        execute_python_code_with_subprocess,
+        add,
+        subtract,
+        multiply,
+        divide,
+    ]