Update tools/recipe_tools.py

tools/recipe_tools.py

@@ -1,67 +1,54 @@
-from dataclasses import dataclass
-from typing import List, Dict
+from typing import List, Dict, Optional
 import re
 from collections import defaultdict
 from smolagents import tool
-from bs4 import BeautifulSoup
-import requests
-
-@dataclass
-class Recipe:
-    title: str
-    ingredients: List[Dict]
-    instructions: List[str]
-    prep_time: Optional[str] = None
-    cook_time: Optional[str] = None
-    servings: Optional[int] = None
-    source_url: Optional[str] = None
-
 
 @tool
-def safe_webpage_visit(url: str) -> Dict:
+def parse_recipe_ingredients(recipe_text: str) -> List[Dict]:
     """
-    Safely attempts to visit a webpage and extract recipe content with fallback options.
+    Parses and structures recipe ingredients from text.
     
     Args:
-        url: The URL of the recipe webpage
+        recipe_text: Text containing recipe ingredients
         
     Returns:
-        Dictionary containing recipe information or error status
+        List of dictionaries containing structured ingredient information
     """
-    try:
-        # First try using the provided VisitWebpageTool
-        from tools.visit_webpage import VisitWebpageTool
-        content = VisitWebpageTool().visit(url)
-        return {
-            "success": True,
-            "content": content,
-            "method": "visit_webpage_tool"
-        }
-    except Exception as e:
-        try:
-            # Fallback to requests if VisitWebpageTool fails
-            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'
-            }
-            response = requests.get(url, headers=headers, timeout=10)
-            response.raise_for_status()
-            return {
-                "success": True,
-                "content": response.text,
-                "method": "requests"
-            }
-        except Exception as e2:
-            return {
-                "success": False,
-                "error": str(e2),
-                "method": None
-            }
-
+    ingredients = []
+    lines = [line.strip() for line in recipe_text.split('\n') if line.strip()]
+    
+    for line in lines:
+        # Basic regex pattern for ingredient parsing
+        pattern = r'^([\d./]+)?\s*([a-zA-Z]+)?\s*(.*?)(?:\((.*?)\))?$'
+        match = re.match(pattern, line.strip())
+        
+        if match:
+            amount_str, unit, name, notes = match.groups()
+            
+            # Convert amount to float
+            try:
+                amount = float(amount_str) if amount_str else 0.0
+            except ValueError:
+                # Handle fractions like "1/2"
+                if amount_str and '/' in amount_str:
+                    num, denom = amount_str.split('/')
+                    amount = float(num) / float(denom)
+                else:
+                    amount = 0.0
+                    
+            ingredients.append({
+                "name": name.strip() if name else "",
+                "amount": amount,
+                "unit": unit.strip() if unit else "",
+                "notes": notes.strip() if notes else ""
+            })
+    
+    return ingredients
 
 @tool
 def organize_shopping_list(ingredients: List[Dict]) -> str:
     """
-    Organizes ingredients into a categorized shopping list.
+    Creates an organized shopping list from ingredients.
     
     Args:
         ingredients: List of ingredient dictionaries
@@ -70,10 +57,10 @@ def organize_shopping_list(ingredients: List[Dict]) -> str:
         Formatted shopping list as a string
     """
     categories = {
-        "Produce": ["vegetable", "fruit", "herb", "leafy", "tomato", "potato", "onion", "garlic"],
-        "Dairy & Eggs": ["milk", "cheese", "cream", "butter", "yogurt", "egg"],
-        "Meat & Seafood": ["chicken", "beef", "pork", "fish", "seafood", "turkey"],
-        "Pantry Items": ["flour", "sugar", "oil", "vinegar", "sauce", "spice", "seasoning", "salt", "pepper"],
+        "Baking & Dry Goods": ["flour", "sugar", "baking", "powder", "soda", "cocoa", "chocolate", "nuts", "oats"],
+        "Dairy & Eggs": ["milk", "cream", "cheese", "butter", "egg", "yogurt"],
+        "Produce": ["fruit", "vegetable", "tomato", "onion", "garlic", "herb", "lettuce", "carrot"],
+        "Spices & Seasonings": ["salt", "pepper", "spice", "cinnamon", "vanilla", "seasoning"],
         "Other": []
     }
     
@@ -121,39 +108,47 @@ def extract_recipe_info(webpage_content: str) -> Dict:
         webpage_content: HTML content from a recipe webpage
         
     Returns:
-        Dictionary containing recipe metadata and formatted ingredient list
+        Dictionary containing recipe information
     """
-    metadata = {
+    recipe_info = {
         "title": "",
-        "servings": "",
+        "ingredients": [],
+        "instructions": [],
         "prep_time": "",
         "cook_time": "",
-        "total_time": "",
-        "ingredients": [],
-        "shopping_list": ""
+        "servings": ""
     }
     
-    # Extract title
+    # Extract title (looking for common patterns)
     title_pattern = r'<h1[^>]*>(.*?)</h1>'
     title_match = re.search(title_pattern, webpage_content)
     if title_match:
-        metadata["title"] = re.sub(r'<[^>]+>', '', title_match.group(1)).strip()
+        recipe_info["title"] = re.sub(r'<[^>]+>', '', title_match.group(1)).strip()
     
-    # Extract times and servings using common patterns
-    patterns = {
+    # Extract ingredients section
+    ingredients_pattern = r'(?:Ingredients:|INGREDIENTS:)(.*?)(?:Instructions:|INSTRUCTIONS:|Directions:|DIRECTIONS:|Method:|$)'
+    ingredients_match = re.search(ingredients_pattern, webpage_content, re.DOTALL | re.IGNORECASE)
+    if ingredients_match:
+        ingredient_text = ingredients_match.group(1)
+        recipe_info["ingredients"] = parse_recipe_ingredients(ingredient_text)
+    
+    # Extract instructions
+    instructions_pattern = r'(?:Instructions:|INSTRUCTIONS:|Directions:|DIRECTIONS:|Method:)(.*?)(?:Notes:|NOTES:|$)'
+    instructions_match = re.search(instructions_pattern, webpage_content, re.DOTALL | re.IGNORECASE)
+    if instructions_match:
+        instructions_text = instructions_match.group(1)
+        recipe_info["instructions"] = [step.strip() for step in instructions_text.split('\n') if step.strip()]
+    
+    # Extract times and servings
+    time_patterns = {
         "prep_time": r'(?:Prep Time|Preparation Time):\s*(\d+\s*(?:min|hour|hr)s?)',
         "cook_time": r'(?:Cook Time|Cooking Time):\s*(\d+\s*(?:min|hour|hr)s?)',
-        "total_time": r'(?:Total Time):\s*(\d+\s*(?:min|hour|hr)s?)',
-        "servings": r'(?:Serves|Servings|Yield):\s*(\d+(?:-\d+)?)',
+        "servings": r'(?:Serves|Servings|Yield):\s*(\d+(?:-\d+)?)'
     }
     
-    for key, pattern in patterns.items():
+    for key, pattern in time_patterns.items():
         match = re.search(pattern, webpage_content, re.IGNORECASE)
         if match:
-            metadata[key] = match.group(1)
-    
-    # Get ingredients and create shopping list
-    metadata["ingredients"] = parse_recipe_ingredients(webpage_content)
-    metadata["shopping_list"] = organize_shopping_list(metadata["ingredients"])
+            recipe_info[key] = match.group(1)
     
-    return metadata
+    return recipe_info