Update app.py

app.py

@@ -4,34 +4,123 @@ import requests
 import pytz
 import yaml
 from tools.final_answer import FinalAnswerTool
-
+from tools.web_search import DuckDuckGoSearchTool
+import duckduckgo_search
+import requests
+from bs4 import BeautifulSoup
+from typing import List, Dict, Optional
 from Gradio_UI import GradioUI
 
-# Below is an example of a tool that does nothing. Amaze us with your creativity !
+Any = typing.Any
+
+
 @tool
-def my_custom_tool(arg1:str, arg2:int)-> str: #it's import to specify the return type
-    #Keep this format for the description / args / args description but feel free to modify the tool
-    """A tool that does nothing yet 
+def extract_recipe_details(url: str) -> Dict[str, Any]:
+    """
+    Extracts ingredients, instructions, and nutritional information from a recipe webpage.
+
     Args:
-        arg1: the first argument
-        arg2: the second argument
+        url (str): The URL of the recipe page.
+
+    Returns:
+        Dict[str, Any]: A dictionary containing ingredients, instructions, and nutritional data.
     """
-    return "What magic will you build ?"
+    try:
+        headers = {"User-Agent": "Mozilla/5.0"}
+        response = requests.get(url, headers=headers, timeout=10)
+        response.raise_for_status()
+
+        soup = BeautifulSoup(response.text, "html.parser")
+
+        # Extract ingredients
+        possible_ingredient_selectors = ["ul", "li", ".ingredients", ".recipe-ingredients", ".ingredient-list"]
+        ingredients = []
+        
+        for selector in possible_ingredient_selectors:
+            for tag in soup.select(selector):
+                items = [item.get_text(strip=True) for item in tag.find_all("li")]
+                if items:
+                    ingredients.extend(items)
+
+        # Extract instructions
+        possible_instruction_selectors = ["ol", "li", ".instructions", ".recipe-instructions", ".step", ".method"]
+        instructions = []
+        
+        for selector in possible_instruction_selectors:
+            for tag in soup.select(selector):
+                steps = [step.get_text(strip=True) for step in tag.find_all("li")]
+                if steps:
+                    instructions.extend(steps)
+
+        # Extract nutritional information (Look for tables or structured text)
+        possible_nutrition_selectors = [".nutrition", ".nutritional-info", ".nutrition-facts", "table"]
+        nutrition_info = []
+        
+        for selector in possible_nutrition_selectors:
+            for tag in soup.select(selector):
+                text = tag.get_text(strip=True)
+                if text and len(text) > 20:
+                    nutrition_info.append(text)
+
+        # Fallback if no nutrition data found
+        nutrition_text = nutrition_info[0] if nutrition_info else "Nutritional information not available. Check the source link."
+
+        return {
+            "ingredients": ingredients if ingredients else ["Ingredients not found. Check the source link."],
+            "instructions": instructions if instructions else ["Instructions not found. Check the source link."],
+            "nutritional_benefits": nutrition_text
+        }
+    
+    except Exception as e:
+        return {
+            "ingredients": [f"Error extracting ingredients: {str(e)}"],
+            "instructions": [f"Error extracting instructions: {str(e)}"],
+            "nutritional_benefits": f"Error extracting nutritional info: {str(e)}"
+        }
 
 @tool
-def get_current_time_in_timezone(timezone: str) -> str:
-    """A tool that fetches the current local time in a specified timezone.
+def get_healthy_cheat_meal(diet_type: str) -> List[Dict[str, Any]]:
+    """
+    Searches the internet for healthy sweet dish recipes and extracts ingredients, instructions, and nutrition.
+
     Args:
-        timezone: A string representing a valid timezone (e.g., 'America/New_York').
+        diet_type (str): The diet category (e.g., Keto, Paleo, Vegan, Vegetarian, Non-Vegetarian).
+
+    Returns:
+        List[Dict[str, Any]]: A list of recipe dictionaries.
     """
+    query = f"healthy {diet_type} sweet dish recipe with ingredients, instructions, and nutrition facts"
+    
     try:
-        # Create timezone object
-        tz = pytz.timezone(timezone)
-        # Get current time in that timezone
-        local_time = datetime.datetime.now(tz).strftime("%Y-%m-%d %H:%M:%S")
-        return f"The current local time in {timezone} is: {local_time}"
+        # Perform web search using DuckDuckGo
+        search_results = duckduckgo_search.ddg(query, max_results=5)
+        
+        if not search_results:
+            return [{"error": "No recipes found. Try a different diet type or check your query."}]
+        
+        recipes = []
+        
+        for result in search_results:
+            url = result.get("href", "")
+            recipe_details = extract_recipe_details(url) if url else {
+                "ingredients": ["No source available."],
+                "instructions": ["No source available."],
+                "nutritional_benefits": "No source available."
+            }
+            
+            recipes.append({
+                "recipe_name": result.get("title", "Unknown Recipe"),
+                "ingredients": recipe_details["ingredients"],
+                "nutritional_benefits": recipe_details["nutritional_benefits"],
+                "adaptations": f"This recipe follows a {diet_type} diet. Some modifications may be needed.",
+                "instructions": recipe_details["instructions"],
+                "source": url
+            })
+        
+        return recipes
+    
     except Exception as e:
-        return f"Error fetching time for timezone '{timezone}': {str(e)}"
+        return [{"error": f"An error occurred while searching: {str(e)}"}]
 
 
 final_answer = FinalAnswerTool()
@@ -48,7 +137,7 @@ custom_role_conversions=None,
 
 
 # Import tool from Hub
-image_generation_tool = load_tool("agents-course/text-to-image", trust_remote_code=True)
+#image_generation_tool = load_tool("agents-course/text-to-image", trust_remote_code=True)
 
 with open("prompts.yaml", 'r') as stream:
     prompt_templates = yaml.safe_load(stream)