without submitting, just to test

agent.py

@@ -0,0 +1,116 @@
+import os
+from dotenv import load_dotenv
+from langgraph.prebuilt import ToolNode
+from typing import TypedDict, Annotated, Literal
+from langchain.chat_models import init_chat_model
+from langgraph.graph import add_messages, StateGraph, START, END
+from langchain_core.messages import AnyMessage, HumanMessage, SystemMessage
+
+from tools import (
+    default_file_reader,
+    image_reader,
+    excel_column_reader,
+    excel_find_column_values_sum,
+    wiki_search,
+    archive_search,
+    get_ioc_code,
+    check_commutativity,
+    audio_to_text,
+    video_to_text
+)
+
+load_dotenv()
+
+class AgentState(TypedDict):
+    messages: Annotated[list[AnyMessage], add_messages]
+
+
+def start_agent(question: str, question_filepath: str):
+    chat = init_chat_model("claude-3-5-sonnet-20241022", model_provider="anthropic", temperature=0)
+
+    tools = [wiki_search, archive_search, get_ioc_code, check_commutativity, video_to_text]
+
+    if question_filepath:
+        #if a file is provided, then add file tools
+        tools = tools + [default_file_reader, image_reader, excel_column_reader, excel_find_column_values_sum, audio_to_text]
+
+    chat_with_tools = chat.bind_tools(tools)
+
+    try:
+        with open("system_prompt.txt", 'r') as sp_file:
+            system_prompt = sp_file.read()
+    except FileNotFoundError:
+        print("Error: unable to open system_prompt.txt")
+        return None
+
+    if question_filepath:
+        messages = [
+            SystemMessage(system_prompt),
+            HumanMessage(content=f"{question} File located at: {question_filepath}")
+        ]
+    else:
+        messages = [
+            SystemMessage(system_prompt),
+            HumanMessage(content=f"{question}")
+        ]
+
+    def assistant(state: AgentState):
+        return {
+            **state,
+            "messages": [chat_with_tools.invoke(state["messages"])],
+        }
+
+    def validate_answer_format(state: AgentState):
+        try:
+            with open("final_answer_validation_prompt.txt", 'r') as favp_file:
+                final_answer_validation_prompt = favp_file.read()
+        except FileNotFoundError:
+            print(f"Error: unable to open final_answer_validation_prompt.txt")
+            return None
+
+        state["messages"].append(
+            HumanMessage(content=f"Verify your FINAL ANSWER again so it meet user question requirements: {question}")
+        )
+
+        state["messages"].append(
+            HumanMessage(content=f"Verify your FINAL ANSWER again so it meets these requirements: {final_answer_validation_prompt}. "
+                                 f"Do not use any tool here, just validate format of the final answer.")
+        )
+
+        return {
+            **state,
+            "messages": [chat_with_tools.invoke(state["messages"])],
+        }
+
+    def custom_tool_condition(state: AgentState, messages_key: str = "messages") -> Literal["tools", "validate"]:
+            if isinstance(state, list):
+                ai_message = state[-1]
+            elif isinstance(state, dict) and (messages := state.get(messages_key, [])):
+                ai_message = messages[-1]
+            elif messages := getattr(state, messages_key, []):
+                ai_message = messages[-1]
+            else:
+                raise ValueError(f"No messages found in input state to tool_edge: {state}")
+            if hasattr(ai_message, "tool_calls") and len(ai_message.tool_calls) > 0:
+                return "tools"
+            return "validate"
+
+    initial_state = AgentState(
+        messages=messages,
+    )
+
+    builder = StateGraph(AgentState)
+
+    builder.add_node("assistant", assistant)
+    builder.add_node("tools", ToolNode(tools))
+    builder.add_node("validate", validate_answer_format)
+
+    builder.add_edge(START, "assistant")
+    builder.add_conditional_edges("assistant", custom_tool_condition)
+
+    builder.add_edge("tools", "assistant")
+    builder.add_edge("validate", END)
+    agent = builder.compile()
+    response = agent.invoke(initial_state)
+
+    return response['messages'][-1].content

app.py

@@ -1,23 +1,42 @@
 import os
-import gradio as gr
-import requests
 import inspect
+import tempfile
+import requests
+import gradio as gr
 import pandas as pd
+from agent import start_agent
 
 # (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("BasicAgent initialized")
+    def __call__(self, question: str, question_filepath: str = "") -> str:
+        answer = start_agent(question, question_filepath)
         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(f"Agent returning answer: {answer}")
+        return answer
+
+
+def download_question_file(task_id: str, filename: str)-> str | None:
+    try:
+        response = requests.get(f"{DEFAULT_API_URL}/files/{task_id}", stream=True)
+        response.raise_for_status()
+
+        temp_dir = tempfile.gettempdir()
+        filepath = os.path.join(temp_dir, filename)
+
+        with open(filepath, 'wb') as file:
+            for chunk in response.iter_content(chunk_size=8192):
+                file.write(chunk)
+
+        return filepath
+    except requests.exceptions.RequestException as e:
+        print(f"Error downloading file: {e}")
+        return None
+
 
 def run_and_submit_all( profile: gr.OAuthProfile | None):
     """
@@ -38,13 +57,13 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
     questions_url = f"{api_url}/questions"
     submit_url = f"{api_url}/submit"
 
-    # 1. Instantiate Agent ( 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)
+    # 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)
 
@@ -75,14 +94,22 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
     print(f"Running agent on {len(questions_data)} questions...")
     for item in questions_data:
         task_id = item.get("task_id")
+        file_name = item.get("file_name")
         question_text = item.get("question")
+        question_filepath = ""
         if not task_id or question_text is None:
             print(f"Skipping item with missing task_id or question: {item}")
             continue
+
+        if file_name:
+            question_filepath = download_question_file(task_id=task_id, filename=file_name)
+
         try:
-            submitted_answer = agent(question_text)
+
+            submitted_answer = agent(question_text, question_filepath)
             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}"})
@@ -90,7 +117,7 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
     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}'..."
@@ -138,6 +165,7 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
         print(status_message)
         results_df = pd.DataFrame(results_log)
         return status_message, results_df
+"""
 
 
 # --- Build Gradio Interface using Blocks ---
@@ -154,7 +182,7 @@ with gr.Blocks() as demo:
         ---
         **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.
+        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 separate action or even to answer the questions in async.
         """
     )
 

final_answer_validation_prompt.txt

@@ -0,0 +1,7 @@
+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 and space 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 on whether the element to be put in the list is a number or a string.
+If the CITY name consists of two or more words, then output them all, but this is applicable ONLY TO CITIES.
+If you solve math problem output answer that tool returned to you.

requirements.txt

@@ -1,2 +1,12 @@
 gradio
-requests
+requests
+requests
+pandas
+pytubefix
+beautifulsoup4
+langchain
+langchain-core
+langchain_community
+langchain-openai
+langchain-anthropic
+langgraph

system_prompt.txt

@@ -0,0 +1,2 @@
+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.

tools.py

@@ -0,0 +1,280 @@
+import os
+import base64
+import requests
+import tempfile
+import pandas as pd
+from openai import OpenAI
+from pytubefix import YouTube
+from langchain_community.tools import tool
+from bs4 import BeautifulSoup, ResultSet, PageElement, Tag, NavigableString
+
+@tool
+def default_file_reader(file_path: str) -> str | None:
+    """
+        Default file reader tool that opens a file as a text reads it content and return it as a string.
+        Use this default tool if there is no specific file reader for a given file.
+    """
+
+    try:
+        with open(file_path, 'r') as file:
+            return file.read()
+    except FileNotFoundError as e:
+        print(f"Error:{e}")
+        return None
+
+
+@tool
+def image_reader(file_path: str) -> dict[str, str | dict[str, str]] | None:
+    """
+        Opens and png image and returns it's data as a dictionary.
+    """
+
+    try:
+        with open(file_path, "rb") as image_file:
+            image_data = base64.b64encode(image_file.read()).decode('utf-8')
+
+        return {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{image_data}"}}
+    except FileNotFoundError as e:
+        print(f"Error:{e}")
+        return None
+
+
+@tool
+def excel_column_reader(file_path: str) -> str | None:
+    """
+        Opens an Excel file, reads the first row to get the names of the columns and return it as a string.
+        Use it to find out what data is available in the Excel file.
+    """
+
+    try:
+        df = pd.read_excel(file_path)
+        return '    '.join(df.columns.astype(str))
+    except FileNotFoundError as e:
+        print(f"Error:{e}")
+        return None
+
+
+@tool
+def excel_find_column_values_sum(file_path: str, columns: list[str]) -> None | int:
+    """Opens an Excel file, find specified columns by column_name and calculates a total sum of all numeric cells of specified columns"""
+
+    try:
+        total = 0
+        df = pd.read_excel(file_path)
+
+        for column in columns:
+            total += df[column].sum()
+
+        return total
+    except FileNotFoundError as e:
+        print(f"Error:{e}")
+        return None
+
+
+@tool
+def wiki_search(query: str) -> str | None:
+    """
+        Search wikipedia by query string and return content of the first found page.
+        Also use it to get information about shows and actors.
+    """
+
+    try:
+        ddg_results = []
+        wiki_results = ""
+        link_rows = _fetch_ddg_search_result_links(f"wikipedia {query}")
+        for link_row in link_rows:
+            if not 'en.wikipedia.org' in link_row.attrs['href']:
+                continue
+
+            ddg_results.append({
+                'title': link_row.get_text(strip=True),
+                'url': link_row.attrs['href']
+            })
+
+            wiki_results += _fetch_specific_page(link_row.attrs['href'])
+            if len(ddg_results) == 1:
+                break
+
+        return wiki_results
+    except requests.exceptions.RequestException as e:
+        print(f"Error during request: {e}")
+        return None
+    except Exception as e:
+        print(f"Error parsing results: {e}")
+        return None
+
+
+@tool
+def archive_search(query: str) -> str | None:
+    """
+        Search archive.org by query string and return content of the first found page.
+        Use this search when you need to find scientific paper or specific scientific publication detail.
+    """
+
+    try:
+        ddg_results = []
+        archive_results = ""
+        link_rows = _fetch_ddg_search_result_links(f"archive.org {query}")
+        for link_row in link_rows:
+            if not 'archive.org' in link_row.attrs['href']:
+                continue
+
+            ddg_results.append({
+                'title': link_row.get_text(strip=True),
+                'url': link_row.attrs['href']
+            })
+
+            archive_results += _fetch_specific_page(link_row.attrs['href'])
+
+            if len(ddg_results) == 1:
+                break
+
+        return archive_results
+    except requests.exceptions.RequestException as e:
+        print(f"Error during request: {e}")
+        return None
+    except Exception as e:
+        print(f"Error parsing results: {e}")
+        return None
+
+
+@tool
+def get_ioc_code(country_name: str) -> str | None:
+    """
+        Accepts country name as a string and returns IOC code of this country.
+    """
+
+    try:
+        ioc_df = pd.read_html('https://en.wikipedia.org/wiki/List_of_IOC_country_codes')[0]
+        ioc_df['Code'] = ioc_df['Code'].str[-3:]
+        name_to_code = dict(zip(ioc_df['National Olympic Committee'], ioc_df['Code']))
+
+        return name_to_code.get(country_name)
+    except Exception as e:
+        print(f"Error: {e}")
+        return None
+
+@tool
+def check_commutativity(table_definition: str) -> str | None:
+    """
+        Use this tool if you need to verify whether a binary operation defined by a table is commutative.
+        Returns dictionary with two fields: "is_commutative"(boolean) and
+        "counter_example_elements" list of elements that violates x∗y=y∗x that prove * is not commutative
+        Example of table definition:
+        |*|a|b|c|d|e|
+        |---|---|---|---|---|---|
+        |a|a|b|c|b|d|
+        |b|b|c|a|e|c|
+        |c|c|a|b|b|a|
+        |d|b|e|b|e|d|
+        |e|d|b|a|d|c|
+    """
+    lines = [line.strip() for line in table_definition.strip().splitlines() if
+             line.strip().startswith('|') and not line.strip().startswith('|-')]
+
+    # Parse header: skip the '*' cell
+    header_cells = [cell.strip() for cell in lines[0].split('|')[1:] if cell.strip()]
+    S = header_cells[1:]  # Skip the first header cell which is "*"
+
+    operation_table = {}
+    for row in lines[1:]:
+        cells = [cell.strip() for cell in row.split('|')[1:] if cell.strip()]
+        row_label = cells[0]
+        values = cells[1:]
+        if len(values) != len(S):
+            raise ValueError(f"Row {row_label} does not have the correct number of entries.")
+        operation_table[row_label] = dict(zip(S, values))
+
+    counter_example_elements = set()
+
+    for x in S:
+        for y in S:
+            if operation_table[x][y] != operation_table[y][x]:
+                counter_example_elements.update([x, y])
+
+
+    return ', '.join(sorted(counter_example_elements)) if len(counter_example_elements) > 0 else None
+
+@tool
+def audio_to_text(file_path: str) -> str | None:
+    """
+        Transcribes audio file to text and returns text as a string.
+    """
+    try:
+        client = OpenAI()
+        audio_file = open(file_path, "rb")
+
+        transcription = client.audio.transcriptions.create(
+            model="gpt-4o-transcribe",
+            file=audio_file
+        )
+
+        return transcription.text
+    except Exception as e:
+        print(f"Error: {e}")
+        return None
+
+@tool
+def video_to_text(video_url: str) -> str | None:
+    """
+        Downloads YouTube video by url, transcribes it to text and returns text as a string.
+    """
+    file_path = ""
+    try:
+        ytx = YouTube(video_url)
+        temp_dir = tempfile.gettempdir()
+        ysx = ytx.streams.get_highest_resolution()
+        file_path = ysx.download(output_path=temp_dir)
+
+        client = OpenAI()
+        video_file = open(file_path, "rb")
+
+        transcription = client.audio.transcriptions.create(
+            model="gpt-4o-transcribe",
+            file=video_file,
+            temperature=0.0,
+            prompt="Ignore music playing in the background and transcribe all conversations."
+        )
+
+        return transcription.text
+    except FileNotFoundError:
+        print(f"Error: File {file_path} was not found.")
+        return None
+    except Exception as e:
+        print(f"Error: {e}")
+        return None
+
+
+def _fetch_ddg_search_result_links(query: str) -> ResultSet[PageElement | Tag | NavigableString]:
+    url = "https://lite.duckduckgo.com/lite/"
+
+    headers = {
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
+        'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
+        'Accept-Language': 'en-US,en;q=0.5',
+    }
+
+    params = {
+        'q': query,
+        'kl': 'us-en'
+    }
+
+    ddg_response = requests.get(url, headers=headers, params=params)
+    ddg_response.raise_for_status()
+
+    soup = BeautifulSoup(ddg_response.text, 'html.parser')
+    return soup.find_all('a', {'class': 'result-link'})
+
+
+def _fetch_specific_page(url: str) -> str:
+    headers = {
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
+        'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
+        'Accept-Language': 'en-US,en;q=0.5',
+    }
+
+    wiki_response = requests.get(url, headers=headers)
+    wiki_response.raise_for_status()
+
+    soup = BeautifulSoup(wiki_response.text, 'html.parser')
+    return soup.get_text()