final solution

agent.py

@@ -3,32 +3,26 @@ import os
 from pathlib import Path
 from typing import Optional
 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.utils import reverse_string, process_excel_file, is_text_file, execute_python_file
 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
-
-# model = LiteLLMModel(
-#     model_id="ollama/qwen2.5:7b",
-#     api_base="http://localhost:11434"
-# )
 
 class BasicAgent:
-    def __init__(self, model):
+    def __init__(self, model, max_steps: int = 10):
         self._model = model
         self._agent = CodeAgent(
-          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],
+          tools=[PythonInterpreterTool(), WikipediaSearchTool(), VisitWebpageTool(), FinalAnswerTool(), optimized_web_search, reverse_string, process_excel_file, is_text_file, load_youtube, execute_python_file, transcribe_audio],
           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
+          max_steps=max_steps
         )
         print("BasicAgent initialized.")
 
     def __call__(self, question: str, file_path: Optional[str] = None) -> str:
-        # print(f"Agent received question (first 50 chars): {question[:50]}...")
+        prompt = question
         if file_path and os.path.exists(file_path):
           try:
               file = Path(file_path)
@@ -36,17 +30,16 @@ class BasicAgent:
                 with open(file_path, "r", encoding="utf-8", errors="ignore") as f:
                   file_content = f.read()
                 if file.suffix == '.py':
-                  question += f"\nAttached Python code:\n{file_path}"
+                  prompt += f"\nAttached Python code:\n{file_path}"
                 else:
-                  question += f"\nAttached File Content:\n{file_content}"
+                  prompt += f"\nAttached File Content:\n{file_content}"
               else:
                 if file.suffix == '.mp3':
-                  question += f"\nUse tool transcribe_audio to extract text from mp3 file.\nAttached mp3 file to transcribes:\n{file_path}"
+                  prompt += f"\nUse tool transcribe_audio to extract text from mp3 file.\nAttached mp3 file to transcribes:\n{file_path}"
                 else:
-                  question += f"\nAttached File Path:\n{file_path}"
+                  prompt += f"\nAttached File Path:\n{file_path}"
           except Exception as e:
               print(f"Failed to read file: {e}")
-        print(question)
-        answer = self._agent.run(question)
-        print(f"Agent returning answer: {answer}")
+        print(prompt)
+        answer = self._agent.run(prompt)
         return answer

app.py

@@ -5,9 +5,10 @@ import requests
 import inspect
 import pandas as pd
 import backoff
+import time
 
 from agent import BasicAgent
-from smolagents import LiteLLMModel
+from smolagents import OpenAIServerModel
 from tools.utils import download_file
 
 # (Keep Constants as is)
@@ -18,7 +19,7 @@ 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:
+    with open('answears.json', 'w') as s:
       s.write(json.dumps(submission_data))
   except:
     pass
@@ -48,11 +49,19 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
 
     # 1. Instantiate Agent ( modify this part to create your agent)
     try:
-        model = LiteLLMModel(
-          model_id="ollama/qwen2.5:7b",
-          api_base="http://localhost:11434"
+        # model = LiteLLMModel(
+        #   model_id="ollama/qwen2.5:7b",
+        #   api_base="http://localhost:11434"
+        # )
+        
+        # Final solution uses mistral-medium-2505
+        model = OpenAIServerModel(
+          model_id="mistral-medium-2505", #the model name in the Mistral documentation
+          api_base="https://api.mistral.ai/v1",  # URL endpoints Mistral
+          api_key=os.getenv('MISTRAL_API_KEY'),
         )
-        agent = BasicAgent(model)
+                
+        agent = BasicAgent(model, max_steps=10)
     except Exception as e:
         print(f"Error instantiating agent: {e}")
         return f"Error initializing agent: {e}", None
@@ -86,6 +95,7 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
     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')

local_development.py

@@ -1,6 +1,5 @@
 import argparse
 import json
-import random
 from agent import BasicAgent
 from smolagents import LiteLLMModel
 from tools.utils import download_file
@@ -8,7 +7,9 @@ from tools.utils import download_file
 
 if __name__ == '__main__':
   parser = argparse.ArgumentParser()
-  parser.add_argument("--id", required=False, type=str, help="Number of question to load", default=None)
+  parser.add_argument('--id', required=False, action="append", help="Number of question to load")
+  parser.add_argument('--max', required=False, type=int, default=10 , help="Number of max steps")
+  answears = {}
   args = parser.parse_args()
   questions = []
   question = None
@@ -17,28 +18,26 @@ if __name__ == '__main__':
   
   with open('questions.json', 'r') as s:
     questions = json.load(s)
-  if args.id:
-    question = [q for q in questions if q['task_id'] == args.id][0]
-    print(f"Process question: {question.get('question')[:50]}")
-  else:
-    n = random.randint(0, len(questions))
-    question = questions[n]
-    print(f"Process random question: {question.get('question')[:50]}")
+    if args.id:
+      questions = [q for q in questions if q.get('task_id') in args.id]
   
-  file_name = question.get('file_name')
-  prompt = question.get('question')
-  
-  if file_name:
+  for question in questions:
+    print(f"Process question: {question.get('question')[:50]}")   
+    file_name = question.get('file_name')
+    prompt = question.get('question')
     task_id = question.get('task_id')
-    file_path = download_file(f'{base_url}/files/{task_id}', file_name)
-  else:
-    file_path = None
-
+    
+    if file_name:
+      file_path = download_file(f'{base_url}/files/{task_id}', file_name)
+    else:
+      file_path = None
 
-  model = LiteLLMModel(
-    model_id="ollama/qwen2.5:7b",
-    api_base="http://localhost:11434"
-  )
-  agent = BasicAgent(model)
-  response = agent(prompt, file_path)
-  print(response)
+    model = LiteLLMModel(
+      model_id="ollama/qwen2.5:7b",
+      api_base="http://localhost:11434"
+    )
+    agent = BasicAgent(model, args.max)
+    response = agent(prompt, file_path)
+    answears[task_id] = response
+    
+  print(answears)

tools/utils.py

@@ -179,6 +179,280 @@ def execute_python_file(file_path: str) -> str:
   except Exception as e:
     return f"Error: Unexpected error: {str(e)}"
 
+
+@tool
+def plural_to_singular(word: str) -> str:
+  """
+  Convert a plural word to its singular form.
+  
+  This function handles common English pluralization patterns including:
+  - Regular plurals ending in 's' (cats -> cat)
+  - Words ending in 'ies' (flies -> fly)
+  - Words ending in 'ves' (knives -> knife)
+  - Words ending in 'es' after sibilants (boxes -> box)
+  - Irregular plurals (children -> child, feet -> foot, etc.)
+  
+  Args:
+    word (str): The plural word to convert to singular form.
+    
+  Returns:
+    str: The singular form of the word.
+    
+  Examples:
+    >>> plural_to_singular("cats")
+    'cat'
+    >>> plural_to_singular("flies")
+    'fly'
+    >>> plural_to_singular("children")
+    'child'
+    >>> plural_to_singular("boxes")
+    'box'
+  """
+  if not word or not isinstance(word, str):
+    return word
+  
+  word = word.lower().strip()
+  
+  # Handle irregular plurals
+  irregular_plurals = {
+    'children': 'child',
+    'feet': 'foot',
+    'teeth': 'tooth',
+    'geese': 'goose',
+    'mice': 'mouse',
+    'men': 'man',
+    'women': 'woman',
+    'people': 'person',
+    'oxen': 'ox',
+    'sheep': 'sheep',
+    'deer': 'deer',
+    'fish': 'fish',
+    'species': 'species',
+    'series': 'series'
+  }
+  
+  if word in irregular_plurals:
+    return irregular_plurals[word]
+  
+  # Handle words ending in 'ies' -> 'y'
+  if word.endswith('ies') and len(word) > 3:
+    return word[:-3] + 'y'
+  
+  # Handle words ending in 'ves' -> 'f' or 'fe'
+  if word.endswith('ves'):
+    if word[:-3] + 'f' in ['leaf', 'loaf', 'thief', 'shelf', 'knife', 'life', 'wife']:
+      return word[:-3] + 'f'
+    elif word == 'wolves':
+      return 'wolf'
+    elif word == 'calves':
+      return 'calf'
+    elif word == 'halves':
+      return 'half'
+  
+  # Handle words ending in 'es' after sibilants (s, ss, sh, ch, x, z)
+  if word.endswith('es') and len(word) > 2:
+    if word[-3:-2] in ['s', 'x', 'z'] or word[-4:-2] in ['sh', 'ch', 'ss']:
+      return word[:-2]
+  
+  # Handle words ending in 'oes' -> 'o'
+  if word.endswith('oes') and len(word) > 3:
+    return word[:-2]
+  
+  # Handle regular plurals ending in 's'
+  if word.endswith('s') and len(word) > 1:
+    return word[:-1]
+  
+  # If no pattern matches, return the original word
+  return word
+  
+@tool
+def is_fruit(item: str) -> bool:
+  """
+  Check if the given item is a recognized fruit.
+  
+  This function determines whether the provided string matches one of the
+  predefined fruits in the internal fruit list. The input is automatically
+  converted to singular form and stripped of whitespace before comparison.
+  
+  The recognized fruits include common varieties such as:
+  - Tree fruits: apple, orange, peach, pear, plum, cherry, lemon, lime
+  - Berries: strawberry, blueberry, raspberry, grape
+  - Tropical fruits: mango, pineapple, kiwi, avocado, pomegranate
+  - Dried fruits: fig, date
+  - And more: banana
+  
+  Args:
+    item (str): The item name to check against the fruit list. Can be
+               singular or plural form.
+    
+  Returns:
+    bool: True if the item is a recognized fruit, False otherwise.
+    
+  Examples:
+    >>> is_fruit("apple")
+    True
+    >>> is_fruit("apples")
+    True
+    >>> is_fruit("  Strawberries  ")
+    True
+    >>> is_fruit("carrot")
+    False
+    >>> is_fruit("banana")
+    True
+    
+  Note:
+    The function uses plural_to_singular() to handle both singular and
+    plural forms of fruit names automatically.
+  """
+  item = plural_to_singular(item.strip())
+  fruits = {
+    'apple', 'banana', 'orange', 'strawberry', 'blueberry', 'raspberry',
+    'mango', 'pineapple', 'grape', 'kiwi', 'peach', 'pear', 'plum',
+    'cherry', 'lemon', 'lime', 'avocado', 'pomegranate', 'fig', 'date'
+  }
+  return item in fruits
+
+@tool
+def is_vegetable(item: str) -> bool:
+  """
+  Check if the given item is a recognized vegetable.
+  
+  This function determines whether the provided string matches one of the
+  predefined vegetables in the internal vegetable list. The input is
+  automatically converted to singular form and stripped of whitespace
+  before comparison.
+  
+  The recognized vegetables include various categories:
+  - Root vegetables: carrot, onion, garlic, potato, sweet potato
+  - Leafy greens: spinach, lettuce, kale, cabbage
+  - Cruciferous: broccoli, cauliflower, cabbage, kale
+  - Nightshades: tomato, pepper, eggplant
+  - Squash family: zucchini
+  - Other: cucumber, celery, mushroom
+  
+  Args:
+    item (str): The item name to check against the vegetable list. Can be
+               singular or plural form.
+    
+  Returns:
+    bool: True if the item is a recognized vegetable, False otherwise.
+    
+  Examples:
+    >>> is_vegetable("carrot")
+    True
+    >>> is_vegetable("carrots")
+    True
+    >>> is_vegetable("  BROCCOLI  ")
+    True
+    >>> is_vegetable("apple")
+    False
+    >>> is_vegetable("mushrooms")
+    True
+    
+  Note:
+    The function uses plural_to_singular() to handle both singular and
+    plural forms of vegetable names automatically. Note that some items
+    like tomatoes are botanically fruits but classified as vegetables
+    in culinary contexts.
+  """
+  item = plural_to_singular(item.strip())
+  vegetables = {
+    'carrot', 'broccoli', 'spinach', 'tomato', 'cucumber', 'lettuce',
+    'onion', 'garlic', 'potato', 'sweet potato', 'zucchini', 'pepper',
+    'eggplant', 'cauliflower', 'cabbage', 'kale', 'mushroom', 'celery'
+  }
+  return item in vegetables
+
+@tool
+def is_product(item: str) -> bool:
+  """
+  Check if the given item is a recognized food product or ingredient.
+  
+  This function determines whether the provided string matches one of the
+  predefined food products in the internal product list. The input is
+  automatically converted to singular form and stripped of whitespace
+  before comparison.
+  
+  The recognized products include various categories:
+  - Baking ingredients: flour, sugar, salt, baking powder, baking soda, yeast
+  - Spices and flavorings: pepper, cinnamon, vanilla, honey
+  - Dairy products: milk, cream, cheese, yogurt, butter
+  - Cooking essentials: oil, vinegar, egg
+  - Beverages and treats: juice, ice cream
+  - Specialty items: cocoa
+  
+  Args:
+    item (str): The item name to check against the product list. Can be
+               singular or plural form.
+    
+  Returns:
+    bool: True if the item is a recognized food product, False otherwise.
+    
+  Examples:
+    >>> is_product("flour")
+    True
+    >>> is_product("eggs")
+    True
+    >>> is_product("  Baking Powder  ")
+    True
+    >>> is_product("carrot")
+    False
+    >>> is_product("ice cream")
+    True
+    
+  Note:
+    The function uses plural_to_singular() to handle both singular and
+    plural forms of product names automatically. Some items like 
+    "ice cream" are treated as compound terms and matched exactly.
+  """
+  item = plural_to_singular(item.strip())
+  products = {
+    'vanilla', 'sugar', 'flour', 'salt', 'pepper', 'oil', 'butter',
+    'milk', 'cream', 'cheese', 'yogurt', 'egg', 'honey', 'vinegar',
+    'baking powder', 'baking soda', 'yeast', 'cinnamon', 'cocoa', 'juice', 'ice cream'
+  }
+  return item in products
+
+@tool
+def is_food(item: str) -> bool:
+  """
+  Check if the given item is a recognized food item.
+  
+  This function determines whether the provided string matches one of the
+  predefined food items in the internal food list. The comparison is
+  case-insensitive and ignores leading/trailing whitespace.
+  
+  The recognized food items are:
+  - burgers
+  - hot dogs
+  - salads
+  - fries
+  - ice cream
+  
+  Args:
+    item (str): The item name to check against the food list.
+    
+  Returns:
+    bool: True if the item is a recognized food item, False otherwise.
+    
+  Examples:
+    >>> is_food("burgers")
+    True
+    >>> is_food("FRIES")
+    True
+    >>> is_food("  Ice Cream  ")
+    True
+    >>> is_food("pizza")
+    False
+    >>> is_food("books")
+    False
+    
+  Note:
+    The function performs case-insensitive matching and automatically
+    strips leading and trailing whitespace from the input.
+  """  
+  return item.lower().strip() in ('burgers', 'hot dogs', 'salads', 'fries', 'ice cream')
+
 @tool
 def get_ingredients(item: str) -> str:
   """
@@ -208,27 +482,10 @@ def get_ingredients(item: str) -> str:
       >>> get_ingredients("APPLE Carrot SUGAR")
       "apple,carrot,sugar"
   """   
-  # Lists of common fruits, vegetables, and products
-  fruits = {
-    'apple', 'banana', 'orange', 'strawberry', 'blueberry', 'raspberry',
-    'mango', 'pineapple', 'grape', 'kiwi', 'peach', 'pear', 'plum',
-    'cherry', 'lemon', 'lime', 'avocado', 'pomegranate', 'fig', 'date'
-  }
-  
-  vegetables = {
-    'carrot', 'broccoli', 'spinach', 'tomato', 'cucumber', 'lettuce',
-    'onion', 'garlic', 'potato', 'sweet potato', 'zucchini', 'pepper',
-    'eggplant', 'cauliflower', 'cabbage', 'kale', 'mushroom', 'celery'
-  }
-  
-  products = {
-    'vanilla', 'sugar', 'flour', 'salt', 'pepper', 'oil', 'butter',
-    'milk', 'cream', 'cheese', 'yogurt', 'egg', 'honey', 'vinegar',
-    'baking powder', 'baking soda', 'yeast', 'cinnamon', 'cocoa'
-  }
+
   
   def is_ingredient(ingredient: str) -> bool:
-    return ingredient in fruits or ingredient in vegetables or ingredient in products
+    return is_fruit(ingredient)  or is_vegetable(ingredient) or is_product(ingredient)
   
   items = set([x.lower().strip() for x in item.split() if is_ingredient(x)])
   return ','.join(sorted(items))