First attempt of running code

.gitignore

@@ -0,0 +1,2 @@
+.venv
+.vscode

agent.py

@@ -0,0 +1,196 @@
+from smolagents import (
+    CodeAgent,
+    InferenceClientModel,
+    WebSearchTool,
+    VisitWebpageTool,
+    WikipediaSearchTool,
+    PythonInterpreterTool,
+    FinalAnswerTool,
+)
+from models import TaskItem
+from smolagents.monitoring import LogLevel
+
+import requests
+import tempfile
+import os
+
+
+class CodingAgent:
+    def __init__(self):
+        model = InferenceClientModel(
+            model_id="Qwen/Qwen2.5-Coder-32B-Instruct",
+        )
+        self._c_agent = CodeAgent(
+            model=model,
+            tools=[PythonInterpreterTool()],
+            name="coding_agent",
+            description="Executes Python code to solve tasks",
+            verbosity_level=LogLevel.INFO,
+            max_steps=10,
+            # add_base_tools=True,
+            additional_authorized_imports=["pandas", "*"],
+        )
+
+    @property
+    def agent(self):
+        """
+        Property that returns the CodeAgent instance
+        """
+        return self._c_agent
+
+
+class WebAgent:
+    def __init__(self):
+        model = InferenceClientModel(
+            model_id="Qwen/Qwen2.5-Coder-32B-Instruct",
+        )
+        self._w_agent = CodeAgent(
+            model=model,
+            tools=[WebSearchTool(), VisitWebpageTool(), WikipediaSearchTool()],
+            name="web_agent",
+            description="Browses the web to find information",
+            verbosity_level=LogLevel.INFO,
+            max_steps=10,
+        )
+
+    @property
+    def agent(self):
+        """
+        Property that returns the CodeAgent instance
+        """
+        return self._w_agent
+
+
+class BudleeAgent:
+
+    # Constructor for SMOL Agent
+
+    _PROMPT = """
+    "I will ask you a question. Report your thoughts step by step. "
+    "Finish your answer only with the final answer. In the final answer don't write explanations. "
+    "The answer should be a number OR as few words as possible OR a comma separated list of numbers and/or strings. "
+    "Avoid units, abbreviations, or articles unless specified. "
+    "Pay attention to each sentence in the question and verify the answer against every part. "
+    "Try searching more sources if initial results are insufficient.\n"
+    "\n"
+    "{additional_context}"
+    "\n"
+    "QUESTION: "
+    ""
+    "{question}"
+    """
+
+    def __init__(self, api_base_url: str):
+        """
+        Initialize the BudleeAgent.
+        This is where you can set up any necessary configurations or parameters.
+        """
+        self._api_url = api_base_url
+        model = InferenceClientModel(
+            max_tokens=4096,
+            temperature=0.2,
+            model_id="deepseek-ai/DeepSeek-R1",  # it is possible that this model may be overloaded
+            custom_role_conversions=None,
+        )
+        agent_web = WebAgent().agent
+        agent_coding = CodingAgent().agent
+        self._manager_agent = CodeAgent(
+            model=model,
+            managed_agents=[agent_web, agent_coding],
+            tools=[
+                FinalAnswerTool(),
+            ],
+            planning_interval=5,
+            verbosity_level=LogLevel.DEBUG,
+            # final_answer_checks=[self._check_response],
+            max_steps=15,
+        )
+
+        self._manager_agent.visualize()
+
+        # def _check_response(self, final_answer, agent_memory):
+        #     """
+        #     Check the final answer response for validity.
+        #     This is a placeholder; implement your own checks as needed.
+        #     """
+        #     # Example: always return True (no check)
+        #     return True
+
+    def answer(self, taskItem: TaskItem) -> str:
+        """
+        Try to solve the task as an Agent using the information
+        """
+        print(f"Agent received question (first 50 chars): {taskItem.question[:50]}...")
+        additional_context =  ""
+
+        # Check if a file is present by validating the file_name is not empty
+
+        if taskItem.file_name and taskItem.file_name.strip():
+            print(f"Agent received file: {taskItem.file_name}")
+            dl_file= self._download_file(taskItem.file_name)
+            additional_context =  f"The question has some additional context from a file that needed to be downloaded. here is the contents of the file\n FILE_CONTENTS: {dl_file}\n"
+
+        prompt = self._PROMPT.format(question=taskItem.question, additional_context=additional_context)
+        print(f"Agent prompt {prompt}")
+        answer = self._manager_agent.run(prompt)
+        # check the answer is FinalStep
+        # if not isinstance(answer, FinalAnswerStep):
+        #     raise ValueError("The agent did not return a FinalAnswerTool instance.")
+
+        # print(f"Agent returning fixed answer: {answer}")
+
+        return answer # type: ignore
+    
+    def _download_file(self, file_name: str) -> str:
+        """
+        Download the file from the given task_id and return its contents as a string.
+        """
+        print(f"Downloading file for task: {file_name}")
+        
+        try:
+            # Construct the API URL - assuming file_name is the task_id
+            api_url = f"{self._api_url}/files/{file_name}"  # Replace with actual base URL
+            
+            # Download the file
+            response = requests.get(api_url)
+            response.raise_for_status()  # Raises an HTTPError for bad responses
+            
+            # Create a temporary file
+            with tempfile.NamedTemporaryFile(mode='w+b', delete=False) as temp_file:
+                temp_file.write(response.content)
+                temp_file_path = temp_file.name
+            
+            try:
+                # Try to read as text with UTF-8 encoding first
+                with open(temp_file_path, 'r', encoding='utf-8') as f:
+                    content = f.read()
+            except UnicodeDecodeError:
+                # If UTF-8 fails, try with latin-1
+                try:
+                    with open(temp_file_path, 'r', encoding='latin-1') as f:
+                        content = f.read()
+                except Exception:
+                    # If all text encodings fail, return binary info
+                    with open(temp_file_path, 'rb') as f:
+                        binary_content = f.read()
+                    content = f"Binary file content (Size: {len(binary_content)} bytes)"
+            finally:
+                # Clean up the temporary file
+                os.unlink(temp_file_path)
+            
+            print(f"File downloaded and processed successfully for task: {file_name}")
+            return content
+            
+        except requests.HTTPError as e:
+            if e.response.status_code == 404:
+                error_msg = f"No file found for task ID: {file_name}"
+            elif e.response.status_code == 403:
+                error_msg = f"Access denied for task ID: {file_name}"
+            else:
+                error_msg = f"HTTP error downloading file for task {file_name}: {e}"
+            print(error_msg)
+            return error_msg
+        except Exception as e:
+            error_msg = f"Error downloading/processing file for task {file_name}: {e}"
+            print(error_msg)
+            return error_msg

app.py

@@ -4,9 +4,13 @@ import requests
 import inspect
 import pandas as pd
 
+from agent import BudleeAgent
+from models import TaskItem
+
 # (Keep Constants as is)
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
+_DEFAULT_AGENT = BudleeAgent(DEFAULT_API_URL)
 
 # --- Basic Agent Definition ---
 # ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
@@ -40,7 +44,7 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
 
     # 1. Instantiate Agent ( modify this part to create your agent)
     try:
-        agent = BasicAgent()
+        agent = _DEFAULT_AGENT
     except Exception as e:
         print(f"Error instantiating agent: {e}")
         return f"Error initializing agent: {e}", None
@@ -80,7 +84,7 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
             print(f"Skipping item with missing task_id or question: {item}")
             continue
         try:
-            submitted_answer = agent(question_text)
+            submitted_answer = agent.answer(taskItem=TaskItem.from_dict(item))
             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:

models.py

@@ -0,0 +1,115 @@
+from dataclasses import dataclass
+from typing import Optional, Dict, Any
+import json
+
+
+@dataclass
+class TaskItem:
+    """
+    Model representing a task/question item from the evaluation system.
+    
+    Attributes:
+        task_id: Unique identifier for the task
+        question: The question text to be answered
+        level: Difficulty level of the task (default: "1")
+        file_name: Associated file name if any (default: empty string)
+    """
+    task_id: str
+    question: str
+    level: str = "1"
+    file_name: str = ""
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> 'TaskItem':
+        """
+        Create TaskItem from dictionary/JSON data.
+        
+        Args:
+            data: Dictionary containing task data
+            
+        Returns:
+            TaskItem instance
+            
+        Raises:
+            ValueError: If required fields are missing
+        """
+        if not data.get("task_id"):
+            raise ValueError("task_id is required")
+        if not data.get("question"):
+            raise ValueError("question is required")
+            
+        return cls(
+            task_id=data["task_id"],
+            question=data["question"],
+            level=data.get("Level", "1"),  # Note: JSON uses "Level" not "level"
+            file_name=data.get("file_name", "")
+        )
+    
+    @classmethod
+    def from_json(cls, json_str: str) -> 'TaskItem':
+        """
+        Create TaskItem from JSON string.
+        
+        Args:
+            json_str: JSON string containing task data
+            
+        Returns:
+            TaskItem instance
+        """
+        data = json.loads(json_str)
+        return cls.from_dict(data)
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Convert TaskItem to dictionary format.
+        
+        Returns:
+            Dictionary representation of the task
+        """
+        return {
+            "task_id": self.task_id,
+            "question": self.question,
+            "Level": self.level,  # Maintain original JSON key format
+            "file_name": self.file_name
+        }
+    
+    def to_json(self) -> str:
+        """
+        Convert TaskItem to JSON string.
+        
+        Returns:
+            JSON string representation of the task
+        """
+        return json.dumps(self.to_dict(), indent=2)
+    
+    def is_valid(self) -> bool:
+        """
+        Check if the TaskItem has valid required fields.
+        
+        Returns:
+            True if task_id and question are non-empty, False otherwise
+        """
+        return bool(self.task_id and self.question)
+    
+    def __str__(self) -> str:
+        """String representation showing task ID and truncated question."""
+        question_preview = self.question[:50] + "..." if len(self.question) > 50 else self.question
+        return f"TaskItem(id={self.task_id}, level={self.level}, question='{question_preview}')"
+
+
+# Example usage and testing
+if __name__ == "__main__":
+    # Example JSON data
+    sample_json = {
+        'task_id': '8e867cd7-cff9-4e6c-867a-ff5ddc2550be',
+        'question': 'How many studio albums were published by Mercedes Sosa between 2000 and 2009 (included)? You can use the latest 2022 version of english wikipedia.',
+        'Level': '1',
+        'file_name': ''
+    }
+    
+    # Create TaskItem from dictionary
+    task = TaskItem.from_dict(sample_json)
+    print("Created TaskItem:")
+    print(task)
+    print("\nIs valid:", task.is_valid())
+    print("\nBack to dict:", task.to_dict())

requirements.txt

@@ -1,2 +1,8 @@
 gradio
-requests
+requests
+gradio[oauth]
+smolagents
+smolagents[toolkit]
+black
+wikipedia-api
+pandas