redesign

.gitignore

@@ -1 +1,2 @@
 __pycache__
+answears.json

agent.py

@@ -2,10 +2,11 @@ import os
 
 from pathlib import Path
 from typing import Optional
-from smolagents import CodeAgent, PythonInterpreterTool, DuckDuckGoSearchTool, Tool
+from smolagents import CodeAgent, PythonInterpreterTool, WikipediaSearchTool, VisitWebpageTool, FinalAnswerTool
 from tools.utils import reverse_string, process_excel_file, is_text_file, execute_python_file, get_ingredients
 from tools.youtube import load_youtube
 from tools.audio import transcribe_audio
+from tools.web import optimized_web_search
 
 # from langchain.agents import load_tools
 
@@ -18,9 +19,11 @@ class BasicAgent:
     def __init__(self, model):
         self._model = model
         self._agent = CodeAgent(
-          tools=[PythonInterpreterTool(), DuckDuckGoSearchTool(), reverse_string, process_excel_file, is_text_file, load_youtube, execute_python_file, transcribe_audio, get_ingredients],
-          additional_authorized_imports=['random', 'time', 'itertools', 'pandas'],
-          model=model
+          tools=[PythonInterpreterTool(), WikipediaSearchTool(), VisitWebpageTool(), FinalAnswerTool(),optimized_web_search, reverse_string, process_excel_file, is_text_file, load_youtube, execute_python_file, transcribe_audio, get_ingredients],
+          additional_authorized_imports=['*', 'subprocess','markdownify', 'chess', 'random', 'time', 'itertools', 'pandas', 'webbrowser', 'requests', 'beautifulsoup4', 'csv', 'openpyxl', 'json', 'yaml'],
+          model=model,
+          add_base_tools=True,
+          max_steps=10
         )
         print("BasicAgent initialized.")
 

app.py

@@ -1,16 +1,31 @@
 import os
+import json
 import gradio as gr
 import requests
 import inspect
 import pandas as pd
+import backoff
 
 from agent import BasicAgent
+from smolagents import LiteLLMModel
+from tools.utils import download_file
 
 # (Keep Constants as is)
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
 
+@backoff.on_exception(backoff.expo, Exception, max_tries=8, max_time=60)
+def submit(submit_url: str, submission_data):
+  try:
+    with open('answears.log', 'w') as s:
+      s.write(json.dumps(submission_data))
+  except:
+    pass
+    
+  response = requests.post(submit_url, json=submission_data, timeout=60)
+  response.raise_for_status()
+  return response
 
 def run_and_submit_all( profile: gr.OAuthProfile | None):
     """
@@ -33,7 +48,11 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
 
     # 1. Instantiate Agent ( modify this part to create your agent)
     try:
-        agent = BasicAgent()
+        model = LiteLLMModel(
+          model_id="ollama/qwen2.5:7b",
+          api_base="http://localhost:11434"
+        )
+        agent = BasicAgent(model)
     except Exception as e:
         print(f"Error instantiating agent: {e}")
         return f"Error initializing agent: {e}", None
@@ -65,15 +84,22 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
     # 3. Run your Agent
     results_log = []
     answers_payload = []
+    file_path = 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")
         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)
+            if file_name:
+              task_id = item.get('task_id')
+              file_path = download_file(f'{DEFAULT_API_URL}/files/{task_id}', file_name)
+            else:
+              file_path = None
+            submitted_answer = str(agent(question_text, 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:
@@ -92,8 +118,7 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
     # 5. Submit
     print(f"Submitting {len(answers_payload)} answers to: {submit_url}")
     try:
-        response = requests.post(submit_url, json=submission_data, timeout=60)
-        response.raise_for_status()
+        response = submit(submit_url, submission_data)
         result_data = response.json()
         final_status = (
             f"Submission Successful!\n"

local_development.py

@@ -31,6 +31,8 @@ if __name__ == '__main__':
   if file_name:
     task_id = question.get('task_id')
     file_path = download_file(f'{base_url}/files/{task_id}', file_name)
+  else:
+    file_path = None
 
 
   model = LiteLLMModel(

requirements.txt

@@ -1,4 +1,5 @@
 gradio
+gradio[oauth]
 requests
 smolagents
 smolagents[litellm]
@@ -11,4 +12,8 @@ langchain
 langchain-community
 backoff
 SpeechRecognition
-pydub
+pydub
+wikipedia-api
+beautifulsoup4
+chess
+markdownify

tools/utils.py

@@ -114,7 +114,7 @@ def is_text_file(file_path: str) -> bool:
 
 
 @tool
-def execute_python_file(file_path: str) -> Union[str|float]:
+def execute_python_file(file_path: str) -> str:
   """
   Execute a Python code from file_path in a separate process and return its output as a numeric value.
   
@@ -125,7 +125,7 @@ def execute_python_file(file_path: str) -> Union[str|float]:
       file_path (str): Path to the Python file to execute.
   
   Returns:
-      Union[str|float]: The output from the executed script, or an error message if execution failed. If output is numeric return float in the other case returns str.
+      str: The output from the executed script, or an error message if execution failed.
   
   Raises:
       None: All exceptions are handled internally and returned as error strings.
@@ -153,7 +153,7 @@ def execute_python_file(file_path: str) -> Union[str|float]:
       [sys.executable, file_path],
       capture_output=True,
       text=True,
-      timeout=60  # 60 seconds timeout
+      timeout=180  # 180 seconds timeout
     )
     
     # If there's stderr output, include it in the result
@@ -163,9 +163,11 @@ def execute_python_file(file_path: str) -> Union[str|float]:
       # Include stderr even if return code is 0 (warnings, etc.)
       return f"{result.stdout.strip()}\nWarnings/Info: {result.stderr.strip()}"
     else:
-      try:
-        return float(result.stdout.strip())
-      except:
+        for i in result.stdout.strip().split():
+          try:
+            return str(int(i.strip()))
+          except:
+            pass
         return result.stdout.strip() if result.stdout.strip() else "Script executed successfully with no output"
     
   except subprocess.TimeoutExpired:

tools/web.py

@@ -0,0 +1,51 @@
+import time
+from smolagents import DuckDuckGoSearchTool
+from smolagents import tool
+
+@tool
+def optimized_web_search(
+    search_query: str, important_words: list, batch_size: int = 500
+) -> str:
+    """A tool that performs a web search and filters the results to only include content chunks that contain important keywords.
+    Args:
+        search_query: The search query to use (e.g., 'Beatles albums Wikipedia')
+        important_words: List of important keywords to filter by (e.g., ['Abbey Road', 'Let It Be', '1970'])
+        batch_size: The size of content chunks to process (default: 500 characters)
+    """
+    try:
+        # Perform the search using DuckDuckGoSearchTool
+        search_tool = DuckDuckGoSearchTool()
+        time.sleep(10)
+        search_results = search_tool.forward(search_query)
+        # Check if search_results is empty or None
+        if not search_results or len(search_results) == 0:
+            return "No search results found."
+
+        # If search_results is a dictionary, extract the content
+        if isinstance(search_results, list):
+            all_content = " ".join(
+                [result.get("content", "") for result in search_results]
+            )
+        else:
+            all_content = search_results
+
+
+        batches = []
+        for i in range(0, len(all_content), batch_size):
+            batches.append(all_content[i : i + batch_size])
+
+        # Filter batches 
+        filtered_batches = []
+        for batch in batches:
+            if any(word.lower() in batch.lower() for word in important_words):
+                filtered_batches.append(batch)
+
+        filtered_content = "\n\n".join(filtered_batches)
+
+        if not filtered_content:
+            return f"No content containing the important words {important_words} was found in the search results."
+
+        return filtered_content
+
+    except Exception as e:
+        return f"Error during optimized web search: {str(e)}"