Upload 48 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+recipe_dataset.csv filter=lfs diff=lfs merge=lfs -text

app/__init__.py

@@ -0,0 +1,18 @@
+from flask import Flask
+from app.api.routes import api_bp
+from app.services.recommendation import FlexibleRecipeRecommendationSystem
+from config import Config
+
+def create_app(config_object=Config):
+    app = Flask(__name__)
+    app.config.from_object(config_object)
+
+    # Initialize the recommendation system with both CSV_FILE_PATH and PRECOMPUTED_DIR
+    app.recommendation_system = FlexibleRecipeRecommendationSystem(
+        app.config['CSV_FILE_PATH'],
+        app.config['PRECOMPUTED_DIR']
+    )
+
+    app.register_blueprint(api_bp)
+
+    return app

app/api/routes.py

@@ -0,0 +1,151 @@
+from flask import Blueprint, Response, request, jsonify, current_app
+from app.models.recipe import Recipe
+import json
+import asyncio
+from app.services import extraction
+from app.services import image_query 
+
+api_bp = Blueprint('api', __name__)
+
+@api_bp.route('/form-data', methods=['GET'])
+def get_form_data():
+    with open('form_data.json', 'r') as file:
+        data = json.load(file)
+    return jsonify(data)
+
+@api_bp.route('/recommend', methods=['POST'])
+async def recommend_recipes():  # Make this function async
+    data = request.json
+    category = data.get('category')
+    dietary_preference = data.get('dietary_preference')
+    ingredients = data.get('ingredients', [])
+    calories = data.get('calories')
+    time = data.get('time')
+    keywords = data.get('keywords', [])
+    keywords_name = data.get('keywords_name', [])
+
+    try:
+        if calories is not None:
+            calories = int(calories)
+        if time is not None:
+            time = int(time)
+    except ValueError:
+        return jsonify({"error": "Calories and time must be integers if provided"}), 400
+
+    # Use await to call the async function
+    recommendations = await current_app.recommendation_system.get_recommendations(
+        category=category,
+        dietary_preference=dietary_preference,
+        ingredients=ingredients,
+        calories=calories,
+        time=time,
+        keywords=keywords,
+        keywords_name=keywords_name
+    )
+
+    return jsonify([vars(recipe) for recipe in recommendations])
+
+@api_bp.route('/extract-recipe-attributes', methods=['POST'])
+async def recommend_recipes2():
+    try:
+        data = request.get_json()
+        if not data:
+            return jsonify({"error": "No data provided"}), 400
+
+        raw_text = data.get('text')
+        if not raw_text:
+            return jsonify({"error": "No search text provided"}), 400
+
+        # Extract recipe attributes
+        extracted_info = extraction.extract_recipe_attributes(raw_text)  # Call the extraction function
+
+        # Check if extraction was successful
+        if 'error' in extracted_info:
+            return jsonify(extracted_info), 500
+
+        # Access the extracted attributes
+        category = extracted_info.get('category', '')
+        calories = extracted_info.get('calories', None)
+        time = extracted_info.get('time', None)
+        keywords = extracted_info.get('keywords', [])
+        keywords_name = extracted_info.get('keywords_name', [])
+
+        # Convert calories and time to integers if they exist
+        try:
+            calories = int(calories) if calories else None
+            time = int(time) if time else None
+        except (ValueError, TypeError):
+            return jsonify({"error": "Invalid calories or time value"}), 400
+
+        # Get recommendations using the recommendation system
+        recommendations = await current_app.recommendation_system.get_recommendations(
+            category=category,
+            ingredients=[],  # Adjust if you plan to add ingredients in the extraction function
+            calories=calories,
+            time=time,
+            keywords=keywords,
+            keywords_name=keywords_name
+        )
+
+        # Convert recommendations to JSON-serializable format
+        recipe_list = [vars(recipe) for recipe in recommendations]
+
+        return jsonify(recipe_list)
+
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+    
+# searchImage
+@api_bp.route('/analyze-food-image', methods=['POST'])
+async def handle_analyze_food_image():
+    try:
+        if 'image' not in request.files:
+            return jsonify({"error": "No image file provided"}), 400
+            
+        file = request.files['image']
+        
+        if file.filename == '':
+            return jsonify({"error": "No selected file"}), 400
+        
+        # Call the analyze function with the file
+        description = image_query.analyze_food_image(file)
+        
+        # Extract recipe attributes
+        extracted_info = extraction.extract_recipe_attributes(description)  # Call the extraction function
+
+        # Check if extraction was successful
+        if 'error' in extracted_info:
+            return jsonify(extracted_info), 500
+
+        # Access the extracted attributes
+        category = extracted_info.get('category', '')
+        calories = extracted_info.get('calories', None)
+        time = extracted_info.get('time', None)
+        keywords = extracted_info.get('keywords', [])
+        keywords_name = extracted_info.get('keywords_name', [])
+
+        # Convert calories and time to integers if they exist
+        try:
+            calories = int(calories) if calories else None
+            time = int(time) if time else None
+        except (ValueError, TypeError):
+            return jsonify({"error": "Invalid calories or time value"}), 400
+
+        # Get recommendations using the recommendation system
+        recommendations = await current_app.recommendation_system.get_recommendations(
+            category=category,
+            ingredients=[],  # Adjust if you plan to add ingredients in the extraction function
+            calories=calories,
+            time=time,
+            keywords=keywords,
+            keywords_name=keywords_name
+        )
+
+        # Convert recommendations to JSON-serializable format
+        recipe_list = [vars(recipe) for recipe in recommendations]
+
+        return jsonify(recipe_list)
+
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+    

app/main.py

@@ -0,0 +1,3 @@
+from app import create_app
+
+app = create_app()

app/models/recipe.py

@@ -0,0 +1,20 @@
+from dataclasses import dataclass
+from typing import List
+
+@dataclass
+class Recipe:
+    RecipeId: int
+    Name: str
+    RecipeCategory: str
+    RecipeIngredientParts: List[str]
+    Keywords: List[str]
+    keywords_name: List[str]  # Add this line
+    Calories: float
+    TotalTime_minutes: int
+    AggregatedRating: float
+    ReviewCount: int
+    Description: str
+    RecipeIngredientQuantities: List[str]
+    RecipeInstructions: List[str]
+    Images: List[str]
+    Similarity: float  # Add this line if it's not already present

app/services/extraction.py

@@ -0,0 +1,701 @@
+import openai
+import json
+from difflib import get_close_matches
+import os
+from dotenv import load_dotenv
+from difflib import SequenceMatcher
+
+load_dotenv() 
+openai.api_key = os.getenv("OPENAI_API_KEY")
+
+# Define categories from dataset
+RECIPE_CATEGORIES = [
+    "frozen desserts",
+    "chicken breast",
+    "beverages",
+    "soy/tofu",
+    "vegetable",
+    "pie",
+    "chicken",
+    "dessert",
+    "southwestern u.s.",
+    "sauces",
+    "stew",
+    "black beans",
+    "< 60 mins",
+    "lactose free",
+    "yeast breads",
+    "whole chicken",
+    "cheesecake",
+    "free of...",
+    "brazilian",
+    "breakfast",
+    "breads",
+    "bar cookie",
+    "brown rice",
+    "oranges",
+    "pork",
+    "low protein",
+    "asian",
+    "potato",
+    "cheese",
+    "halibut",
+    "meat",
+    "lamb/sheep",
+    "very low carbs",
+    "spaghetti",
+    "scones",
+    "drop cookies",
+    "lunch/snacks",
+    "beans",
+    "punch beverage",
+    "pineapple",
+    "quick breads",
+    "sourdough breads",
+    "curries",
+    "chicken livers",
+    "coconut",
+    "savory pies",
+    "poultry",
+    "steak",
+    "healthy",
+    "rice",
+    "apple",
+    "spreads",
+    "crab",
+    "jellies",
+    "pears",
+    "chowders",
+    "cauliflower",
+    "candy",
+    "chutneys",
+    "white rice",
+    "tex mex",
+    "bass",
+    "fruit",
+    "european",
+    "smoothies",
+    "manicotti",
+    "onions",
+    "new zealand",
+    "chicken thigh & leg",
+    "indonesian",
+    "greek",
+    "corn",
+    "lentil",
+    "long grain rice",
+    "southwest asia (middle east)",
+    "spanish",
+    "dutch",
+    "gelatin",
+    "tuna",
+    "citrus",
+    "berries",
+    "peppers",
+    "salad dressings",
+    "clear soup",
+    "mexican",
+    "raspberries",
+    "crawfish",
+    "beef organ meats",
+    "lobster",
+    "strawberry",
+    "shakes",
+    "short grain rice",
+    "< 15 mins",
+    "german",
+    "one dish meal",
+    "thai",
+    "cajun",
+    "russian",
+    "melons",
+    "swiss",
+    "papaya",
+    "veal",
+    "orange roughy",
+    "canadian",
+    "caribbean",
+    "mussels",
+    "medium grain rice",
+    "japanese",
+    "penne",
+    "elk",
+    "colombian",
+    "gumbo",
+    "roast beef",
+    "perch",
+    "vietnamese",
+    "rabbit",
+    "lebanese",
+    "turkish",
+    "kid friendly",
+    "whole turkey",
+    "chinese",
+    "grains",
+    "yam/sweet potato",
+    "meatloaf",
+    "trout",
+    "african",
+    "ham",
+    "goose",
+    "pasta shells",
+    "stocks",
+    "meatballs",
+    "whole duck",
+    "scandinavian",
+    "greens",
+    "catfish",
+    "duck breasts",
+    "polish",
+    "deer",
+    "wild game",
+    "pheasant",
+    "hungarian",
+    "no shell fish",
+    "collard greens",
+    "tilapia",
+    "quail",
+    "moroccan",
+    "squid",
+    "korean",
+    "plums",
+    "danish",
+    "creole",
+    "mahi mahi",
+    "tarts",
+    "hawaiian",
+    "austrian",
+    "moose",
+    "native american",
+    "swedish",
+    "norwegian",
+    "ethiopian",
+    "belgian",
+    "australian",
+    "bear",
+    "scottish",
+    "tempeh",
+    "cuban",
+    "spinach",
+    "turkey breasts",
+    "cantonese",
+    "tropical fruits",
+    "peanut butter",
+    "szechuan",
+    "portuguese",
+    "costa rican",
+    "duck",
+    "nuts",
+    "filipino",
+    "pot pie",
+    "polynesian",
+    "mango",
+    "cherries",
+    "egyptian",
+    "chard",
+    "lime",
+    "lemon",
+    "kiwifruit",
+    "whitefish",
+    "south american",
+    "malaysian",
+    "octopus",
+    "nigerian",
+    "south african",
+    "nepalese",
+    "palestinian",
+    "czech",
+    "avocado",
+    "iraqi",
+    "pakistani",
+    "chocolate chip cookies",
+    "finnish",
+    "puerto rican",
+    "cambodian",
+    "honduran",
+    "mongolian",
+    "peruvian",
+    "turkey gravy",
+    "somalian",
+    "ice cream",
+    "oatmeal",
+    "artichoke",
+    "indian",
+    "grapes",
+    "macaroni and cheese",
+    "mashed potatoes",
+    "pumpkin",
+    "guatemalan"
+]
+
+def find_closest_category(category):
+    """Find the closest matching category from the dataset."""
+    if not category:
+        return ""
+    
+    # First check for exact match
+    if category.lower() in [c.lower() for c in RECIPE_CATEGORIES]:
+        return next(c for c in RECIPE_CATEGORIES if c.lower() == category.lower())
+    
+    # For compound categories, check parts
+    category_parts = category.lower().split()
+    if len(category_parts) == 1 and category_parts[0] in [c.lower() for c in RECIPE_CATEGORIES]:
+        # If the input is a single word that exists in the category list, return it
+        return next(c for c in RECIPE_CATEGORIES if c.lower() == category_parts[0])
+    
+    for part in category_parts:
+        matches = [c for c in RECIPE_CATEGORIES if part in c.lower()]
+        if matches:
+            return matches[0]
+    
+    # If no matches found, use difflib to find closest match
+    matches = get_close_matches(category.lower(), [c.lower() for c in RECIPE_CATEGORIES], n=1, cutoff=0.75)
+    if matches:
+        closest_match = matches[0]
+        # Check if the closest match is close enough (similarity score > 0.8)
+        if SequenceMatcher(None, category.lower(), closest_match).ratio() > 0.8:
+            return next(c for c in RECIPE_CATEGORIES if c.lower() == closest_match)
+        else:
+            return ""
+    
+    # If no match is found at all, return empty string
+    return ""
+
+def extract_recipe_attributes(text):
+    messages = [
+        {"role": "system", "content": "You are an assistant that extracts recipe attributes from user input. If the input contains an uncommon or unrecognized category, add relevant general keywords based on common culinary types, such as 'beverages' for drinks, 'dessert' for sweets, etc."},
+        {"role": "user", "content": f"""
+From the given text, identify:
+- **category**: The main name or type of the recipe (like "chicken", "ice cream"). 
+- **calories**: Number of calories, if mentioned.
+- **time**: Time to cook, in minutes.
+- **keywords**: Important words related to the recipe. If the category is not common (like "noodles" or "biryani"), include relevant characteristics (e.g., "asian", "main course", "stir fry", "quick meal", "wheat based", "high protein", etc).
+- **keywords_name**: List of individual words from the category/name. For uncommon categories, include descriptive terms and related categories (e.g., for "noodles": ["asian", "pasta", "wheat", "main dish"]).
+
+Examples:
+---
+Input: "noodles"
+Output: {{
+    "category": "",
+    "calories": "",
+    "time": "",
+    "keywords": ["asian", "stir fry", "wheat based", "quick meal", "main course", "pasta", "noodles"],
+    "keywords_name": ["asian", "pasta", "main dish", "wheat"]
+}}
+
+---
+Input: "biryani"
+Output: {{
+    "category": "",
+    "calories": "",
+    "time": "",
+    "keywords": ["rice", "indian", "spicy", "main course", "one dish meal", "biryani"],
+    "keywords_name": ["rice", "indian", "spicy"]
+}}
+
+---
+Input: "sushi"
+Output: {{
+    "category": "",
+    "calories": "",
+    "time": "",
+    "keywords": ["japanese", "rice", "seafood", "whitefish", "snack", "main course", "sushi"],
+    "keywords_name": ["japanese", "seafood", "rice"]
+}}
+
+---
+Input: "vegetable curry"
+Output: {{
+    "category": "",
+    "calories": "",
+    "time": "",
+    "keywords": ["vegan", "vegetarian", "spicy", "main course", "curry", "indian"],
+    "keywords_name": ["indian", "vegetarian", "spicy"]
+}}
+         
+---
+Input: "quinoa salad"
+Output: {{
+    "category": "salad dressings",
+    "calories": "",
+    "time": "",
+    "keywords": ["healthy", "salad", "gluten-free", "fiber", "low calorie", "vegan"],
+    "keywords_name": ["healthy", "salad", "vegan"]
+}}
+
+---
+Input: "beef tacos"
+Output: {{
+    "category": "beef organ meats",
+    "calories": "",
+    "time": "",
+    "keywords": ["mexican", "beef", "spicy", "snack", "tortilla", "street food"],
+    "keywords_name": ["mexican", "beef", "snack"]
+}}
+
+---
+Input: "caesar salad"
+Output: {{
+    "category": "salad dressings",
+    "calories": "",
+    "time": "",
+    "keywords": ["salad", "appetizer", "healthy", "vegetables", "parmesan", "croutons"],
+    "keywords_name": ["salad", "appetizer", "healthy"]
+}}
+
+
+---
+Input: "smoothie bowl"
+Output: {{
+    "category": "smoothies",
+    "calories": "",
+    "time": "",
+    "keywords": ["breakfast", "healthy", "fruits", "smoothies", "vegan", "fiber"],
+    "keywords_name": ["breakfast", "healthy", "fruits"]
+}}
+
+Input: "spaghetti bolognese"
+Output: {{
+    "category": "spaghetti",
+    "calories": "",
+    "time": "",
+    "keywords": ["italian", "pasta", "meat", "tomato", "main course", "hearty"],
+    "keywords_name": ["italian", "pasta", "meat"]
+}}
+         
+---
+Input: "I wish to cook chicken soup which contains around 200 calories within 30 mins"
+Output: {{
+    "category": "chicken",
+    "calories": "200",
+    "time": "30",
+    "keywords": ["chicken", "soup", "200 calories", "30 mins"],
+    "keywords_name": ["chicken", "soup"]
+}}
+
+---
+Input: "Quick pasta recipe with 500 calories, ready in 20 mins"
+Output: {{
+    "category": "pasta shells",
+    "calories": "500",
+    "time": "20",
+    "keywords": ["pasta shells", "500 calories", "20 mins"],
+    "keywords_name": ["pasta shells"]
+}}
+
+---
+Input: "uh i wish to cook something which contains protein"
+Output: {{
+    "category": "low protein",
+    "calories": "",
+    "time": "",
+    "keywords": ["low protein", "high protein", "protein"],
+    "keywords_name": ["low protein"]
+}}
+
+---
+Input: "can you suggest something with low calories"
+Output: {{
+    "category": "",
+    "calories": "",
+    "time": "",
+    "keywords": ["low calories"],
+    "keywords_name": ["low", "calories"]
+}}
+
+---
+Input: "looking for a vegetarian recipe"
+Output: {{
+    "category": "",
+    "calories": "",
+    "time": "",
+    "keywords": ["vegetarian", "vegan"],
+    "keywords_name": ["vegetarian"]
+}}
+
+---
+Input: "need something gluten free"
+Output: {{
+    "category": "",
+    "calories": "",
+    "time": "",
+    "keywords": ["gluten free"],
+    "keywords_name": ["gluten", "free"]
+}}
+
+---
+Input: "want to make something dairy free"
+Output: {{
+    "category": "",
+    "calories": "",
+    "time": "",
+    "keywords": ["dairy free", "vegan"],
+    "keywords_name": ["dairy", "free"]
+}}
+
+---
+Input: "what can i cook for dinner"
+Output: {{
+    "category": "",
+    "calories": "",
+    "time": "",
+    "keywords": ["dinner", "vegan"],
+    "keywords_name": [""]
+}}
+
+---
+Input: "what can i cook for breakfast"
+Output: {{
+    "category": "",
+    "calories": "",
+    "time": "",
+    "keywords": ["breakfast", "vegan"],
+    "keywords_name": [""]
+}}
+
+---
+Input: "what can i cook for lunch"
+Output: {{
+    "category": "",
+    "calories": "",
+    "time": "",
+    "keywords": ["lunch", "quick meal", "vegan"],
+    "keywords_name": [""]
+}}
+         
+---
+Input: "something with low carbs"
+Output: {{
+    "category": "very low carbs",
+    "calories": "",
+    "time": "",
+    "keywords": ["very low carbs", "low carbs", "carbs"],
+    "keywords_name": ["low", "carbs"]
+}}
+         
+---
+Input: "i wish to cook something in 30 minutes"
+Output: {{
+    "category": "",
+    "calories": "",
+    "time": "30",
+    "keywords": ["30 minutes", "quick meal"],
+    "keywords_name": [""]
+}}
+
+---
+Input: "I wish to make fish and stew"
+Output: {{
+    "category": "stew",
+    "calories": "",
+    "time": "",
+    "keywords": ["fish", "stew", "high protein"],
+    "keywords_name": ["fish", "stew"]
+}}
+
+---
+Input: "I wish to make fish and stew"
+Output: {{
+    "category": "catfish",
+    "calories": "",
+    "time": "",
+    "keywords": ["fish", "stew", "high protein"],
+    "keywords_name": ["fish", "stew"]
+}}
+
+---
+Input: "I wish to make fish and stew"
+Output: {{
+    "category": "whitefish",
+    "calories": "",
+    "time": "",
+    "keywords": ["fish", "stew", "high protein"],
+    "keywords_name": ["fish", "stew"]
+}}
+
+---
+Input: "I wish to make fish and stew"
+Output: {{
+    "category": "crawfish",
+    "calories": "",
+    "time": "",
+    "keywords": ["fish", "stew", "high protein"],
+    "keywords_name": ["fish", "stew"]
+}} 
+               
+---
+Input: "give some recipes involving almonds or dry fruits"
+Output: {{
+    "category": "",
+    "calories": "",
+    "time": "",
+    "keywords": ["almonds", "dry fruits"],
+    "keywords_name": ["almonds", "dry fruits"]
+}}
+
+---
+Input: "tea with milk, sugar, water"
+Output: {{
+    "category": "",
+    "calories": "",
+    "time": "",
+    "keywords": ["milk", "sugar", "water", "beverages"],
+    "keywords_name": [""]
+}}
+
+---
+Input: "chole bhature"
+Output: {{
+    "category": "",
+    "calories": "",
+    "time": "",
+    "keywords": ["gluten free"],
+    "keywords_name": ["gluten", "free"]
+}}
+
+---
+Input: "something involving nuts"
+Output: {{
+    "category": "nuts",
+    "calories": "",
+    "time": "",
+    "keywords": ["nuts", "snack", "healthy", "protein", "fiber"],
+    "keywords_name": ["nuts", "snack", "healthy"]
+}}
+            
+---
+Now process this input:
+Input: "{text}"
+Output:
+"""}
+    ]
+
+    # Send the prompt to OpenAI API
+    response = openai.ChatCompletion.create(
+        model="gpt-3.5-turbo",
+        messages=messages,
+        temperature=0,
+        max_tokens=150,
+        top_p=1,
+        frequency_penalty=0,
+        presence_penalty=0,
+    )
+
+    # Process the response
+    output_text = response['choices'][0]['message']['content'].strip()
+    
+    try:
+        result = json.loads(output_text)
+        # Update category with closest match from dataset
+        original_category = result["category"]
+        matched_category = find_closest_category(original_category)
+        
+        if matched_category:
+            # If we found a match (exact or close), update category and keywords_name
+            result["category"] = matched_category
+            if original_category != matched_category:
+                result["keywords_name"] = matched_category.split()
+        else:
+            result["category"] = ""
+            # Add additional context-based keywords if category is empty
+            if "coffee" in text.lower() or "latte" in text.lower():
+                result["keywords"] = result.get("keywords", []) + ["coffee", "beverages", "caffeinated", "hot drink"]
+                result["keywords_name"] = result.get("keywords_name", []) + ["beverages", "caffeinated", "coffee"]
+            elif "espresso" in text.lower():
+                result["keywords"] = result.get("keywords", []) + ["beverages", "caffeinated", "espresso"]
+                result["keywords_name"] = result.get("keywords_name", []) + ["beverages", "espresso"]
+            elif "smoothie bowl" in text.lower():
+                result["keywords"] = result.get("keywords", []) + ["beverages", "healthy", "smoothie bowl"]
+                result["keywords_name"] = result.get("keywords_name", []) + ["beverages", "smoothie bowl"]
+            elif "kombucha" in text.lower():
+                result["keywords"] = result.get("keywords", []) + ["beverage", "fermented", "kombucha"]
+                result["keywords_name"] = result.get("keywords_name", []) + ["beverages", "kombucha"]
+            elif "herbal tea" in text.lower():
+                result["keywords"] = result.get("keywords", []) + ["beverages", "caffeine-free", "herbal tea"]
+                result["keywords_name"] = result.get("keywords_name", []) + ["beverages", "herbal tea"]
+            elif "seaweed" in text.lower():
+                result["keywords"] = result.get("keywords", []) + ["ingredient", "seafood", "seaweed"]
+                result["keywords_name"] = result.get("keywords_name", []) + ["seaweed"]
+            elif "vegan cheese" in text.lower():
+                result["keywords"] = result.get("keywords", []) + ["dairy-free", "vegan", "cheese"]
+                result["keywords_name"] = result.get("keywords_name", []) + ["vegan cheese"]
+            elif "air fryer" in text.lower():
+                result["keywords"] = result.get("keywords", []) + ["cooking method", "air fryer", "healthy"]
+                result["keywords_name"] = result.get("keywords_name", []) + ["air fryer"]
+            elif "instant pot" in text.lower():
+                result["keywords"] = result.get("keywords", []) + ["cooking method", "instant pot", "pressure cooker"]
+                result["keywords_name"] = result.get("keywords_name", []) + ["instant pot"]
+            elif "sous vide" in text.lower():
+                result["keywords"] = result.get("keywords", []) + ["cooking method", "sous vide", "precision cooking"]
+                result["keywords_name"] = result.get("keywords_name", []) + ["sous vide"]
+            elif "paleo" in text.lower():
+                result["keywords"] = result.get("keywords", []) + ["diet", "paleo", "low-carb"]
+                result["keywords_name"] = result.get("keywords_name", []) + ["paleo"]
+            elif "fodmap" in text.lower():
+                result["keywords"] = result.get("keywords", []) + ["diet", "fodmap", "digestive health"]
+                result["keywords_name"] = result.get("keywords_name", []) + ["fodmap"]
+            elif "cold brew" in text.lower():
+                result["keywords"] = result.get("keywords", []) + ["beverages", "caffeinated", "cold coffee"]
+                result["keywords_name"] = result.get("keywords_name", []) + ["beverages", "cold brew"]
+            elif "matcha" in text.lower():
+                result["keywords"] = result.get("keywords", []) + ["beverages", "green tea", "matcha"]
+                result["keywords_name"] = result.get("keywords_name", []) + ["beverages", "matcha"]
+            elif "smoothie" in text.lower():
+                result["keywords"] = result.get("keywords", []) + ["beverages", "healthy", "smoothie"]
+                result["keywords_name"] = result.get("keywords_name", []) + ["beverages", "smoothie"]
+            elif "protein shake" in text.lower():
+                result["keywords"] = result.get("keywords", []) + ["beverages", "high protein", "shake"]
+                result["keywords_name"] = result.get("keywords_name", []) + ["beverages", "protein shake"]
+            elif "oat milk" in text.lower() or "almond milk" in text.lower():
+                result["keywords"] = result.get("keywords", []) + ["dairy-free", "vegan", "plant-based milk"]
+                result["keywords_name"] = result.get("keywords_name", []) + ["oat milk" if "oat" in text.lower() else "almond milk"]
+            elif "zoodles" in text.lower():
+                result["keywords"] = result.get("keywords", []) + ["low carb", "gluten-free", "vegetable noodles", "noodles"]
+                result["keywords_name"] = result.get("keywords_name", []) + ["zoodles", "noodles"]
+            elif "avocado toast" in text.lower():
+                result["keywords"] = result.get("keywords", []) + ["breakfast", "healthy", "avocado"]
+                result["keywords_name"] = result.get("keywords_name", []) + ["avocado toast"]
+            elif "golden milk" in text.lower():
+                result["keywords"] = result.get("keywords", []) + ["beverage", "turmeric", "anti-inflammatory"]
+                result["keywords_name"] = result.get("keywords_name", []) + ["golden milk"]
+            # Add other cases as needed
+            
+    except json.JSONDecodeError:
+        result = {"error": "Failed to parse JSON", "output": output_text}
+    
+    return result
+
+# Example usage:
+if __name__ == '__main__':
+    test_cases = [
+        # "noodles",
+        # "need a pasta recipe",
+        # "looking for a chicken dish",
+        # "want to make something with rice",
+        # "need a dessert recipe",
+        # "biryani",
+        # "30 mins",
+        # "chole bhature",
+        # "give some recipes involving almonds",
+        # "latte with foam, coffee, milk",
+        # "cold drink beverage",
+        # "beans",
+        # "coffee",
+        # "latte",
+        # "something involving nuts",
+        # "i wish to cook something with crab",
+        # "livers",
+        # "popcorn",
+        # "beef stew with potatoes, carrots, and herbs.",
+        # "dessert with chocolate, brownie, cake"
+        # "chocolate, brownie, cake, brown sugar",
+        # "avocado smoothie, avocado, milk, ice",
+        # "momo, momo, sauce",
+        # "I have basil, tomato and clove what can i make in 30 minutes",
+        "basil"
+    ]
+    
+    for test_input in test_cases:
+        print(f"\nTesting: {test_input}")
+        result = extract_recipe_attributes(test_input)
+        print(json.dumps(result, indent=2)) 

app/services/image_query.py

@@ -0,0 +1,50 @@
+from flask import Flask, request, jsonify
+import google.generativeai as genai
+import PIL.Image
+import io
+import os
+from dotenv import load_dotenv
+app = Flask(__name__)
+load_dotenv()
+
+# Configure Gemini API - get key from https://makersuite.google.com/app/apikey
+GOOGLE_API_KEY = os.getenv('GOOGLE_API_KEY')
+genai.configure(api_key=GOOGLE_API_KEY)
+
+# Initialize the model - UPDATED MODEL NAME HERE
+model = genai.GenerativeModel('gemini-1.5-flash')  # Changed from gemini-pro-vision
+
+def analyze_food_image(image_content) -> str:
+    """
+    Analyze image using Gemini API and return food description
+    """
+    try:
+        prompt = """
+        Look at this food image and:
+        1. Identify the main dish/food item
+        2. List visible ingredients or components, including individual words/strings of the main dish
+        3. Return ONLY a simple description in this format: [main dish], [ingredients]
+        For example: "pizza, pizza, cheese, tomatoes, basil" or "chocolate cake, chocolate, cake, frosting, berries"
+        """
+        
+        # Convert bytes to PIL Image
+        image_bytes = image_content.read()
+        image = PIL.Image.open(io.BytesIO(image_bytes))
+        
+        # Generate response
+        response = model.generate_content([prompt, image])
+        
+        # Clean and format the response
+        description = response.text.strip().lower()
+        description = description.replace('"', '').replace("'", '')
+
+        print(description) # For testing purpose
+
+        return description if description else "food dish"
+        
+    except Exception as e:
+        print(f"Error in analysis: {str(e)}")
+        return f"food dish (Error: {str(e)})"
+
+if __name__ == '__main__':
+    pass

app/services/image_search.py

@@ -0,0 +1,126 @@
+import logging
+import asyncio
+import aiohttp
+import random
+import re
+from typing import List, Union
+from app.utils.scrapers.google_scraper import GoogleScraper
+from app.utils.scrapers.food_network_scraper import FoodNetworkScraper
+from app.utils.scrapers.allrecipes_scraper import AllRecipesScraper
+from app.utils.scrapers.wikimedia_scraper import WikimediaScraper
+from app.utils.scrapers.fooddotcom_scraper import FoodDotComScraper
+
+logger = logging.getLogger(__name__)
+
+class ImageSearchService:
+    def __init__(self):
+        self.scrapers = [
+            GoogleScraper(),
+            FoodNetworkScraper(),
+            AllRecipesScraper(),
+            WikimediaScraper(),
+            FoodDotComScraper()
+        ]
+        self.session = None
+        self.placeholder_images = [
+            "https://drive.google.com/file/d/1gYOjs06yiq7EUXaO19BE-L7MkrTR6wlc/view?usp=sharing",
+            "https://drive.google.com/file/d/1ob4KbzVLtwsE_ckYKBu_70FLEXNCJRSr/view?usp=sharing",
+            "https://drive.google.com/file/d/1UUv3zF1ouXteZVt8Oc_UXORcJrlWfRXR/view?usp=sharing"
+        ]
+
+    async def __aenter__(self):
+        if self.session is None:
+            self.session = aiohttp.ClientSession()
+            for scraper in self.scrapers:
+                scraper.session = self.session
+        logger.info("ImageSearchService session initialized")
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        if self.session:
+            await self.session.close()
+            self.session = None
+        logger.info("ImageSearchService session closed")
+
+    async def search_recipe_images(self, recipe_name: str, image_data: Union[str, float, int], num_images: int = 3) -> List[str]:
+        logger.info(f"Searching images for recipe: {recipe_name}")
+        
+        # First try to get existing URLs from the database
+        existing_urls = self.extract_urls_from_image_column(image_data)
+        if existing_urls:
+            logger.info(f"Found {len(existing_urls)} existing URLs")
+            return existing_urls[:num_images]
+        
+        try:
+            # Try to get images from scrapers
+            all_results = []
+            tasks = []
+            
+            for scraper in self.scrapers:
+                task = asyncio.create_task(scraper.search_images(recipe_name, num_images))
+                tasks.append(task)
+            
+            logger.info(f"Created {len(tasks)} scraper tasks")
+            done, pending = await asyncio.wait(tasks, timeout=60)
+            
+            for task in pending:
+                logger.warning(f"Cancelling pending task for {task.get_coro().__name__}")
+                task.cancel()
+            
+            for task in done:
+                try:
+                    results = await task
+                    logger.info(f"Scraper {task.get_coro().__name__} found {len(results)} images")
+                    all_results.extend(results)
+                except Exception as e:
+                    logger.error(f"Error in scraper task {task.get_coro().__name__}: {str(e)}")
+            
+            # Get unique results
+            seen = set()
+            unique_results = []
+            for url in all_results:
+                if url not in seen:
+                    seen.add(url)
+                    unique_results.append(url)
+            
+            if unique_results:
+                logger.info(f"Found {len(unique_results)} unique image URLs")
+                return unique_results[:num_images]
+            
+            # If no images found, return random placeholder images
+            logger.info("No images found, using placeholder images")
+            selected_placeholders = []
+            for _ in range(num_images):
+                placeholder = random.choice(self.placeholder_images)
+                while placeholder in selected_placeholders and len(selected_placeholders) < len(self.placeholder_images):
+                    placeholder = random.choice(self.placeholder_images)
+                selected_placeholders.append(placeholder)
+            
+            return selected_placeholders
+            
+        except Exception as e:
+            logger.error(f"Error in image search: {str(e)}")
+            # Return placeholder images even in case of error
+            return random.sample(self.placeholder_images, min(num_images, len(self.placeholder_images)))
+
+    def extract_urls_from_image_column(self, image_data: Union[str, float, int]) -> List[str]:
+        logger.debug(f"Extracting URLs from image data: {image_data}")
+        if image_data is None or image_data == 'NA' or isinstance(image_data, (float, int)):
+            logger.debug("No valid image data found in database")
+            return []
+        
+        try:
+            image_data_str = str(image_data)
+            urls = []
+            if image_data_str.startswith('c(') and image_data_str.endswith(')'):
+                content = image_data_str[2:-1].strip()
+                parts = re.findall(r'"([^"]*)"', content)
+                urls = [url for url in parts if url.startswith('http')]
+            else:
+                urls = re.findall(r'https?://[^\s,"\')]+', image_data_str)
+            
+            logger.info(f"Extracted {len(urls)} URLs from image column")
+            return urls
+        except Exception as e:
+            logger.error(f"Error extracting URLs from image data: {str(e)}")
+            return []

app/services/recommendation.py

@@ -0,0 +1,28 @@
+import logging
+from app.services.image_search import ImageSearchService
+from app.utils.data_loading import load_or_create_data
+from app.utils.recommendation_utils import get_top_recommendations
+
+logger = logging.getLogger(__name__)
+
+class FlexibleRecipeRecommendationSystem:
+    def __init__(self, csv_file_path, precomputed_dir):
+        self.feature_weights = {
+            'ingredients': 0.15, 'category': 0.25, 'dietary': 0.20,
+            'calories': 0.10, 'time': 0.10, 'keywords': 0.10, 'keywords_name': 0.10
+        }
+        self.image_search_service = ImageSearchService()
+        self.data = load_or_create_data(csv_file_path, precomputed_dir, self.feature_weights)
+
+    async def get_recommendations(self, category=None, dietary_preference=None, ingredients=None, 
+                                  calories=None, time=None, keywords=None, keywords_name=None, top_n=6):
+        return await get_top_recommendations(
+            self.data['df'], self.data['combined_matrix'], 
+            self.data['tfidf_vectorizer_ingredients'],
+            self.data['tfidf_vectorizer_keywords'], 
+            self.data['tfidf_vectorizer_keywords_name'],
+            self.data['category_dummies'], self.data['scaler'], 
+            self.feature_weights, self.image_search_service,
+            category, dietary_preference, ingredients, 
+            calories, time, keywords, keywords_name, top_n
+        )

app/utils/data_loading.py

@@ -0,0 +1,47 @@
+import os
+import joblib
+from scipy.sparse import save_npz, load_npz
+import pandas as pd
+from app.utils.data_preprocessing import preprocess_data
+from app.utils.feature_engineering import create_feature_matrices
+
+def load_or_create_data(csv_file_path, precomputed_dir, feature_weights):
+    files = ['df', 'tfidf_vectorizer_ingredients', 'tfidf_vectorizer_keywords',
+             'tfidf_vectorizer_keywords_name', 'category_dummies', 'scaler']
+    
+    if all(os.path.exists(os.path.join(precomputed_dir, f'{f}.joblib')) for f in files) and \
+       os.path.exists(os.path.join(precomputed_dir, 'combined_matrix.npz')):
+        return load_precomputed_data(precomputed_dir)
+    else:
+        return compute_and_save_data(csv_file_path, precomputed_dir, feature_weights)
+
+def load_precomputed_data(precomputed_dir):
+    data = {}
+    for f in ['df', 'tfidf_vectorizer_ingredients', 'tfidf_vectorizer_keywords',
+              'tfidf_vectorizer_keywords_name', 'category_dummies', 'scaler']:
+        data[f] = joblib.load(os.path.join(precomputed_dir, f'{f}.joblib'))
+    data['combined_matrix'] = load_npz(os.path.join(precomputed_dir, 'combined_matrix.npz'))
+    return data
+
+def compute_and_save_data(csv_file_path, precomputed_dir, feature_weights):
+    df = preprocess_data(pd.read_csv(csv_file_path))
+    results = create_feature_matrices(df, feature_weights)
+    combined_matrix, tfidf_vectorizer_ingredients, tfidf_vectorizer_keywords, \
+    tfidf_vectorizer_keywords_name, category_dummies, scaler = results
+
+    os.makedirs(precomputed_dir, exist_ok=True)
+    data = {
+        'df': df,
+        'tfidf_vectorizer_ingredients': tfidf_vectorizer_ingredients,
+        'tfidf_vectorizer_keywords': tfidf_vectorizer_keywords,
+        'tfidf_vectorizer_keywords_name': tfidf_vectorizer_keywords_name,
+        'category_dummies': category_dummies,
+        'scaler': scaler,
+        'combined_matrix': combined_matrix
+    }
+    for name, obj in data.items():
+        if name == 'combined_matrix':
+            save_npz(os.path.join(precomputed_dir, f'{name}.npz'), obj)
+        else:
+            joblib.dump(obj, os.path.join(precomputed_dir, f'{name}.joblib'))
+    return data

app/utils/data_preprocessing.py

@@ -0,0 +1,108 @@
+import pandas as pd
+import numpy as np
+import ast
+import logging
+import re
+
+logger = logging.getLogger(__name__)
+
+def parse_r_vector(s):
+    """
+    Parse R vector format strings like c("word1", "word2") into Python lists.
+    
+    Args:
+        s: String in R vector format
+        
+    Returns:
+        List of strings
+    """
+    if pd.isna(s):
+        return []
+    
+    try:
+        # Remove the c() wrapper and split by commas
+        if isinstance(s, str) and s.startswith('c(') and s.endswith(')'):
+            # Extract content between c( and )
+            content = s[2:-1].strip()
+            
+            # Use regex to properly split quoted strings
+            pattern = r'"([^"]*)"'
+            matches = re.findall(pattern, content)
+            
+            # Filter out empty strings and NA values
+            ingredients = [item.strip() for item in matches if item.strip() and item.lower() != 'na']
+            return ingredients
+        elif isinstance(s, list):
+            return s
+        else:
+            return []
+    except Exception as e:
+        logger.warning(f"Error parsing R vector: {s}, Error: {str(e)}")
+        return []
+
+def preprocess_data(df):
+    """
+    Preprocess the dataframe by handling boolean, numerical, and list-like columns.
+    """
+    bool_columns = ['is_vegetarian', 'is_vegan', 'is_gluten free', 'is_dairy free', 
+                    'is_low carb', 'is_keto', 'is_paleo']
+    for col in bool_columns:
+        df[col] = df[col].map({'TRUE': 1, 'FALSE': 0, True: 1, False: 0}).fillna(0).astype(int)
+    
+    numerical_columns = ['Calories', 'TotalTime_minutes', 'AggregatedRating', 'ReviewCount']
+    for col in numerical_columns:
+        df[col] = pd.to_numeric(df[col], errors='coerce')
+        median_value = df[col].median()
+        df[col] = df[col].fillna(median_value)
+    
+    # Handle R vector format columns
+    r_vector_columns = ['RecipeIngredientParts', 'RecipeInstructions', 'RecipeIngredientQuantities']
+    for col in r_vector_columns:
+        df[col] = df[col].apply(parse_r_vector)
+    
+    # Handle regular list columns
+    list_columns = ['Keywords', 'keywords_name']
+    for col in list_columns:
+        df[col] = df[col].apply(parse_list_string)
+    
+    return df
+
+def parse_list_string(s):
+    """
+    Safely parse list-like strings.
+    """
+    if pd.isna(s):
+        return []
+    try:
+        if isinstance(s, str):
+            parsed = ast.literal_eval(s)
+            return parsed if isinstance(parsed, list) else [s]
+        elif isinstance(s, list):
+            return s
+        return []
+    except (ValueError, SyntaxError):
+        return [s] if s else []
+
+def parse_recipe_ingredients(ingredient_parts):
+    """
+    Parse RecipeIngredientParts field handling R vector format.
+    """
+    return parse_r_vector(ingredient_parts)
+
+def parse_list_field(field):
+    """
+    Parse a list field, handling various input types including R vectors.
+    """
+    if pd.isna(field):
+        return []
+    if isinstance(field, list):
+        return field
+    elif isinstance(field, str):
+        if field.startswith('c('):
+            return parse_r_vector(field)
+        try:
+            parsed = ast.literal_eval(field)
+            return parsed if isinstance(parsed, list) else []
+        except (ValueError, SyntaxError):
+            return []
+    return []

app/utils/feature_engineering.py

@@ -0,0 +1,118 @@
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.preprocessing import MinMaxScaler
+from scipy.sparse import hstack
+import pandas as pd
+import numpy as np
+
+def create_feature_matrices(df, feature_weights):
+    """
+    Create feature matrices for the recommendation system.
+    """
+    tfidf_vectorizer_ingredients = TfidfVectorizer(
+        stop_words='english',
+        max_features=5000,
+        ngram_range=(1, 2),
+        min_df=1
+    )
+    
+    ingredients_text = df['RecipeIngredientParts'].apply(lambda x: ' '.join(x) if x else '')
+    tfidf_matrix_ingredients = tfidf_vectorizer_ingredients.fit_transform(ingredients_text)
+
+    tfidf_vectorizer_keywords = TfidfVectorizer(stop_words='english', max_features=3000)
+    tfidf_vectorizer_keywords_name = TfidfVectorizer(stop_words='english', max_features=3000)
+    
+    keywords_text = df['Keywords'].apply(lambda x: ' '.join(x) if x else '')
+    keywords_name_text = df['keywords_name'].apply(lambda x: ' '.join(x) if x else '')
+    
+    tfidf_matrix_keywords = tfidf_vectorizer_keywords.fit_transform(keywords_text)
+    tfidf_matrix_keywords_name = tfidf_vectorizer_keywords_name.fit_transform(keywords_name_text)
+
+    category_dummies = pd.get_dummies(df['RecipeCategory'])
+    category_matrix = category_dummies.values
+
+    dietary_columns = ['is_vegetarian', 'is_vegan', 'is_gluten free', 'is_dairy free', 
+                     'is_low carb', 'is_keto', 'is_paleo']
+    dietary_matrix = df[dietary_columns].values
+
+    scaler = MinMaxScaler()
+    calories_matrix = scaler.fit_transform(df[['Calories']].values)
+    time_matrix = scaler.fit_transform(df[['TotalTime_minutes']].values)
+    rating_matrix = scaler.fit_transform(df[['AggregatedRating']].values)
+
+    combined_matrix = hstack([
+        tfidf_matrix_ingredients * feature_weights['ingredients'],
+        category_matrix * feature_weights['category'],
+        dietary_matrix * feature_weights['dietary'],
+        calories_matrix * feature_weights['calories'],
+        time_matrix * feature_weights['time'],
+        tfidf_matrix_keywords * feature_weights['keywords'],
+        tfidf_matrix_keywords_name * feature_weights['keywords_name'],
+        rating_matrix * 0.05  # Small weight for ratings in base similarity
+    ])
+
+    return (combined_matrix, tfidf_vectorizer_ingredients, tfidf_vectorizer_keywords, 
+            tfidf_vectorizer_keywords_name, category_dummies, scaler)
+
+def create_query_vector(combined_matrix, tfidf_vectorizer_ingredients, tfidf_vectorizer_keywords,
+                        tfidf_vectorizer_keywords_name, category_dummies, scaler, feature_weights, **kwargs):
+    """
+    Create a query vector based on user input.
+    """
+    query_vector = np.zeros((1, combined_matrix.shape[1]))
+    current_position = 0
+
+    if kwargs.get('ingredients'):
+        ingredients_query = tfidf_vectorizer_ingredients.transform([' '.join(kwargs['ingredients'])])
+        query_vector[:, :ingredients_query.shape[1]] = ingredients_query.toarray() * feature_weights['ingredients']
+        current_position += ingredients_query.shape[1]
+
+    category_vector = np.zeros((1, category_dummies.shape[1]))
+    if kwargs.get('category') and kwargs['category'] in category_dummies.columns:
+        category_index = category_dummies.columns.get_loc(kwargs['category'])
+        category_vector[0, category_index] = 1
+    query_vector[:, current_position:current_position + category_dummies.shape[1]] = (
+        category_vector * feature_weights['category']
+    )
+    current_position += category_dummies.shape[1]
+
+    dietary_columns = ['is_vegetarian', 'is_vegan', 'is_gluten free', 'is_dairy free', 
+                       'is_low carb', 'is_keto', 'is_paleo']
+    dietary_vector = np.zeros((1, len(dietary_columns)))
+    if kwargs.get('dietary_preference') in dietary_columns:
+        dietary_index = dietary_columns.index(kwargs['dietary_preference'])
+        dietary_vector[0, dietary_index] = 1
+    query_vector[:, current_position:current_position + len(dietary_columns)] = (
+        dietary_vector * feature_weights['dietary']
+    )
+    current_position += len(dietary_columns)
+
+    calories_vector = np.zeros((1, 1))
+    time_vector = np.zeros((1, 1))
+    
+    if kwargs.get('calories'):
+        calories_vector[0, 0] = kwargs['calories']
+    if kwargs.get('time'):
+        time_vector[0, 0] = kwargs['time']
+        
+    calories_vector = scaler.transform(calories_vector)
+    time_vector = scaler.transform(time_vector)
+    
+    query_vector[:, current_position:current_position + 1] = calories_vector * feature_weights['calories']
+    current_position += 1
+    query_vector[:, current_position:current_position + 1] = time_vector * feature_weights['time']
+    current_position += 1
+
+    if kwargs.get('keywords'):
+        keywords_query = tfidf_vectorizer_keywords.transform([' '.join(kwargs['keywords'])])
+        query_vector[:, current_position:current_position + keywords_query.shape[1]] = (
+            keywords_query.toarray() * feature_weights['keywords']
+        )
+        current_position += keywords_query.shape[1]
+
+    if kwargs.get('keywords_name'):
+        keywords_name_query = tfidf_vectorizer_keywords_name.transform([' '.join(kwargs['keywords_name'])])
+        query_vector[:, current_position:current_position + keywords_name_query.shape[1]] = (
+            keywords_name_query.toarray() * feature_weights['keywords_name']
+        )
+
+    return query_vector

app/utils/recommendation_utils.py

@@ -0,0 +1,66 @@
+import logging
+from app.models.recipe import Recipe
+from app.utils.feature_engineering import create_query_vector
+from app.utils.similarity_calculation import calculate_weighted_similarity
+
+logger = logging.getLogger(__name__)
+
+async def get_top_recommendations(df, combined_matrix, tfidf_vectorizer_ingredients,
+                                  tfidf_vectorizer_keywords, tfidf_vectorizer_keywords_name,
+                                  category_dummies, scaler, feature_weights, image_search_service,
+                                  category=None, dietary_preference=None, ingredients=None, 
+                                  calories=None, time=None, keywords=None, keywords_name=None, top_n=5):
+    logger.info(f"Starting recommendation process for category: {category}, dietary_preference: {dietary_preference}")
+    
+    query_vector = create_query_vector(combined_matrix, tfidf_vectorizer_ingredients,
+                                       tfidf_vectorizer_keywords, tfidf_vectorizer_keywords_name,
+                                       category_dummies, scaler, feature_weights,
+                                       category=category, dietary_preference=dietary_preference,
+                                       ingredients=ingredients, calories=calories, time=time,
+                                       keywords=keywords, keywords_name=keywords_name)
+
+    similarity_scores = calculate_weighted_similarity(query_vector, combined_matrix, df, calories, time)
+    
+    if category:
+        similarity_scores *= (df['RecipeCategory'] == category)
+
+    top_indices = similarity_scores.argsort()[-top_n*3:][::-1]
+    logger.info(f"Found {len(top_indices)} potential recommendations")
+
+    results = []
+    async with image_search_service as image_service:
+        for idx in top_indices:
+            if len(results) >= top_n:
+                break
+
+            recipe = df.iloc[idx]
+            
+            if category and recipe['RecipeCategory'] != category:
+                continue
+
+            try:
+                image_urls = await image_service.search_recipe_images(recipe['Name'], recipe['Images'], 3)
+            except Exception as e:
+                logger.error(f"Error searching images for {recipe['Name']}: {str(e)}")
+                image_urls = []
+
+            results.append(Recipe(
+                RecipeId=int(recipe['RecipeId']),
+                Name=recipe['Name'],
+                RecipeCategory=recipe['RecipeCategory'],
+                RecipeIngredientParts=recipe['RecipeIngredientParts'],
+                Keywords=recipe['Keywords'],
+                keywords_name=recipe['keywords_name'],
+                Calories=float(recipe['Calories']),
+                TotalTime_minutes=int(recipe['TotalTime_minutes']),
+                AggregatedRating=float(recipe['AggregatedRating']),
+                ReviewCount=int(recipe['ReviewCount']),
+                Description=recipe['Description'],
+                RecipeIngredientQuantities=recipe['RecipeIngredientQuantities'],
+                RecipeInstructions=recipe['RecipeInstructions'],
+                Images=image_urls,
+                Similarity=float(similarity_scores[idx])
+            ))
+
+    logger.info(f"Returning {len(results)} recommendations")
+    return results[:top_n]

app/utils/scrapers/allrecipes_scraper.py

@@ -0,0 +1,38 @@
+from bs4 import BeautifulSoup
+from urllib.parse import quote
+from typing import List
+from .base_scraper import BaseScraper
+import logging
+
+logger = logging.getLogger(__name__)
+
+class AllRecipesScraper(BaseScraper):
+    async def search_images(self, recipe_name: str, num_images: int) -> List[str]:
+        search_query = quote(recipe_name)
+        url = f"https://www.allrecipes.com/search?q={search_query}"
+        
+        try:
+            async with self.session.get(url, headers=await self.get_headers()) as response:
+                if response.status != 200:
+                    return []
+                
+                html = await response.text()
+                soup = BeautifulSoup(html, 'html.parser')
+                images = set()
+                
+                for img in soup.find_all('img'):
+                    src = img.get('src') or img.get('data-src')
+                    if src and not any(x in src.lower() for x in ['icon', 'logo', 'advertisement']):
+                        images.add(src)
+                
+                valid_images = []
+                for img_url in images:
+                    if len(valid_images) >= num_images:
+                        break
+                    if await self.verify_image_url(img_url):
+                        valid_images.append(img_url)
+                
+                return valid_images
+        except Exception as e:
+            logger.error(f"AllRecipes scraping error: {str(e)}")
+            return []

app/utils/scrapers/base_scraper.py

@@ -0,0 +1,38 @@
+import random
+import aiohttp
+from abc import ABC, abstractmethod
+from typing import List
+import logging
+
+logger = logging.getLogger(__name__)
+
+class BaseScraper(ABC):
+    def __init__(self):
+        self.user_agents = [
+            'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
+            'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:89.0) Gecko/20100101 Firefox/89.0',
+            'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.0 Safari/605.1.15',
+        ]
+        self.session = None
+
+    async def get_headers(self):
+        return {
+            'User-Agent': random.choice(self.user_agents),
+            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
+            'Accept-Language': 'en-US,en;q=0.5',
+            'Referer': 'https://www.google.com/',
+        }
+
+    @abstractmethod
+    async def search_images(self, recipe_name: str, num_images: int) -> List[str]:
+        pass
+
+    async def verify_image_url(self, url: str) -> bool:
+        try:
+            async with self.session.head(url, allow_redirects=True, timeout=60) as response:
+                content_type = response.headers.get('content-type', '')
+                return (response.status == 200 and 
+                       'image' in content_type and 
+                       not any(x in url.lower() for x in ['placeholder', 'default', 'missing']))
+        except:
+            return False

app/utils/scrapers/food_network_scraper.py

@@ -0,0 +1,39 @@
+from bs4 import BeautifulSoup
+from urllib.parse import quote
+from .base_scraper import BaseScraper
+from typing import List
+
+import logging
+
+logger = logging.getLogger(__name__)
+
+class FoodNetworkScraper(BaseScraper):
+    async def search_images(self, recipe_name: str, num_images: int) -> List[str]:
+        search_query = quote(recipe_name)
+        url = f"https://www.foodnetwork.com/search/{search_query}-"
+        
+        try:
+            async with self.session.get(url, headers=await self.get_headers()) as response:
+                if response.status != 200:
+                    return []
+                
+                html = await response.text()
+                soup = BeautifulSoup(html, 'html.parser')
+                images = set()
+                
+                for img in soup.find_all('img', {'data-src': True}):
+                    src = img.get('data-src')
+                    if src and 'thumbnail' not in src.lower():
+                        images.add(src)
+                
+                valid_images = []
+                for img_url in images:
+                    if len(valid_images) >= num_images:
+                        break
+                    if await self.verify_image_url(img_url):
+                        valid_images.append(img_url)
+                
+                return valid_images
+        except Exception as e:
+            logger.error(f"Food Network scraping error: {str(e)}")
+            return []

app/utils/scrapers/fooddotcom_scraper.py

@@ -0,0 +1,65 @@
+from bs4 import BeautifulSoup
+import re
+from typing import List
+from urllib.parse import quote
+from .base_scraper import BaseScraper
+import logging
+
+logger = logging.getLogger(__name__)
+
+class FoodDotComScraper(BaseScraper):
+    async def search_images(self, recipe_name: str, num_images: int) -> List[str]:
+        search_query = quote(recipe_name)
+        url = f"https://www.food.com/search/{search_query}?pn=1"
+        
+        try:
+            async with self.session.get(url, headers=await self.get_headers()) as response:
+                if response.status != 200:
+                    return []
+                
+                html = await response.text()
+                soup = BeautifulSoup(html, 'html.parser')
+                images = set()
+                
+                # Look for recipe cards which usually contain the main images
+                recipe_cards = soup.find_all('div', {'class': 'recipe-card'})
+                for card in recipe_cards:
+                    # Check for lazy-loaded images
+                    img_tags = card.find_all('img', {'data-src': True})
+                    for img in img_tags:
+                        src = img.get('data-src')
+                        if src:
+                            # Food.com often uses different image sizes, try to get the largest
+                            # Replace size parameters in URL to get larger images
+                            src = re.sub(r's\d+-c', 's800-c', src)
+                            images.add(src)
+                    
+                    # Check for regular images
+                    img_tags = card.find_all('img', {'src': True})
+                    for img in img_tags:
+                        src = img.get('src')
+                        if src and not any(x in src.lower() for x in ['icon', 'logo', 'advertisement']):
+                            src = re.sub(r's\d+-c', 's800-c', src)
+                            images.add(src)
+                
+                # If no recipe cards found, try finding images in the main content
+                if not images:
+                    img_tags = soup.find_all('img', {'class': 'recipe-image'})
+                    for img in img_tags:
+                        src = img.get('src') or img.get('data-src')
+                        if src:
+                            src = re.sub(r's\d+-c', 's800-c', src)
+                            images.add(src)
+                
+                valid_images = []
+                for img_url in images:
+                    if len(valid_images) >= num_images:
+                        break
+                    if await self.verify_image_url(img_url):
+                        valid_images.append(img_url)
+                
+                return valid_images
+                
+        except Exception as e:
+            logger.error(f"Food.com scraping error: {str(e)}")
+            return []

app/utils/scrapers/google_scraper.py

@@ -0,0 +1,42 @@
+from bs4 import BeautifulSoup
+import re
+from urllib.parse import quote, unquote
+from .base_scraper import BaseScraper
+import logging
+from typing import List
+
+
+logger = logging.getLogger(__name__)
+
+class GoogleScraper(BaseScraper):
+    async def search_images(self, recipe_name: str, num_images: int) -> List[str]:
+        search_query = f"{recipe_name} recipe food"
+        url = f"https://www.google.com/search?q={quote(search_query)}&tbm=isch"
+        
+        try:
+            async with self.session.get(url, headers=await self.get_headers()) as response:
+                if response.status != 200:
+                    return []
+                
+                html = await response.text()
+                soup = BeautifulSoup(html, 'html.parser')
+                images = set()
+
+                # Extract from JSON-like data in scripts
+                for script in soup.find_all('script'):
+                    if script.string and 'AF_initDataCallback' in script.string:
+                        urls = re.findall(r'(https?://\S+\.(?:jpg|jpeg|png))', script.string)
+                        images.update(unquote(url) for url in urls)
+
+                # Verify URLs and take only valid ones
+                valid_images = []
+                for img_url in images:
+                    if len(valid_images) >= num_images:
+                        break
+                    if await self.verify_image_url(img_url):
+                        valid_images.append(img_url)
+
+                return valid_images
+        except Exception as e:
+            logger.error(f"Google scraping error: {str(e)}")
+            return []

app/utils/scrapers/wikimedia_scraper.py

@@ -0,0 +1,45 @@
+from urllib.parse import quote
+from typing import List
+from .base_scraper import BaseScraper
+import logging
+
+logger = logging.getLogger(__name__)
+
+class WikimediaScraper(BaseScraper):
+    async def search_images(self, recipe_name: str, num_images: int) -> List[str]:
+        search_query = quote(recipe_name)
+        url = f"https://commons.wikimedia.org/w/api.php"
+        params = {
+            "action": "query",
+            "format": "json",
+            "list": "search",
+            "srsearch": f"{search_query} food",
+            "srnamespace": "6",  # File namespace
+            "srlimit": num_images
+        }
+        
+        try:
+            async with self.session.get(url, params=params, headers=await self.get_headers()) as response:
+                if response.status != 200:
+                    return []
+                
+                data = await response.json()
+                images = set()
+                
+                for item in data.get('query', {}).get('search', []):
+                    title = item.get('title', '')
+                    if title.startswith('File:'):
+                        file_url = f"https://commons.wikimedia.org/wiki/Special:FilePath/{quote(title[5:])}"
+                        images.add(file_url)
+                
+                valid_images = []
+                for img_url in images:
+                    if len(valid_images) >= num_images:
+                        break
+                    if await self.verify_image_url(img_url):
+                        valid_images.append(img_url)
+                
+                return valid_images
+        except Exception as e:
+            logger.error(f"Wikimedia scraping error: {str(e)}")
+            return []

app/utils/similarity_calculation.py

@@ -0,0 +1,22 @@
+from sklearn.metrics.pairwise import cosine_similarity
+import numpy as np
+
+def calculate_weighted_similarity(query_vector, combined_matrix, df, target_calories=None, target_time=None):
+    """
+    Calculate weighted similarity scores between the query vector and the combined matrix.
+    """
+    base_similarity = cosine_similarity(query_vector, combined_matrix).flatten()
+    
+    penalties = np.ones_like(base_similarity)
+    
+    if target_calories is not None:
+        calorie_diff = np.abs(df['Calories'].values - target_calories)
+        calorie_penalty = 1 - (calorie_diff / df['Calories'].max())
+        penalties *= calorie_penalty
+        
+    if target_time is not None:
+        time_diff = np.abs(df['TotalTime_minutes'].values - target_time)
+        time_penalty = 1 - (time_diff / df['TotalTime_minutes'].max())
+        penalties *= time_penalty
+    
+    return base_similarity * penalties

config.py

@@ -0,0 +1,6 @@
+import os
+
+class Config:
+    CSV_FILE_PATH = os.path.join(os.path.dirname(__file__), 'recipe_dataset.csv')
+    PRECOMPUTED_DIR = 'precomputed'
+

precomputed/category_dummies.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f16cabab6b55b1592c9645bd51bae137af0a740b165c983be6d2e70a5a4ce010
+size 165342541

precomputed/combined_matrix.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b6192a266f00edac60dc58ae9414d925313df00f32d51fa063816b69931f23ac
+size 146356536

precomputed/df.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d96d26fed0f3b971dc44a540e4a55260e1ce3d966f1dd50b22e98bf8e08dafd9
+size 799635866

precomputed/scaler.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3ee2fe48286554095f1c37aaff1dd00cf264cce4ce89a6aadc04de24a421a365
+size 719

precomputed/tfidf_vectorizer_ingredients.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7450c31c3bca4362d8f95282756baf6a97dc0b57c9c1b06328e06212a5bc9789
+size 208006

precomputed/tfidf_vectorizer_keywords.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:91c80bcf57cc31d546f0362cb4d54d0eff63ce903d026a45aaa287322afdeca4
+size 15243

precomputed/tfidf_vectorizer_keywords_name.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6eda812093fd905b029de6c59f3db10586d09570d8508b677cceb4f9a58bcadf
+size 109419

recipe_dataset.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:076a78cbd94ba5b8b0cba19591b0d96edcedd8d020d0143aae63b81eda3d1e91
+size 713412559

run.py

@@ -0,0 +1,11 @@
+# run.py
+from app import create_app
+from flask import Flask, jsonify
+from flask_cors import CORS
+import json
+
+app = create_app()
+CORS(app, resources={r"/*": {"origins": "http://localhost:3000"}})
+
+if __name__ == '__main__':
+    app.run(debug=True)