Upload 8 files

Dockerfile

@@ -0,0 +1,30 @@
+# Use an official lightweight Python image.
+FROM python:3.10-slim
+
+# Install system dependencies required by some Python packages.
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    git \
+    wget \
+    && rm -rf /var/lib/apt/lists/*
+
+# Set the working directory inside the container.
+WORKDIR /app
+
+# Copy the requirements file and install the Python dependencies.
+# This helps leverage Docker's layer caching when dependencies don’t change.
+COPY requirements.txt .
+RUN pip install --upgrade pip && pip install -r requirements.txt
+
+# Copy your entire project into the container.
+COPY . .
+
+# Set an environment variable for the port; your code defaults to port 7860.
+ENV PORT=7860
+
+# Expose the port (Hugging Face Spaces will map this externally).
+EXPOSE 7860
+
+# Define the command to run your Flask app.
+# Make sure the file name below matches the name of your main Python file.
+CMD ["python", "app.py"]

app.py

@@ -0,0 +1,621 @@
+from flask import Flask, request, jsonify
+import pandas as pd
+from transformers import pipeline
+import os
+import re
+import json
+import requests
+import random
+from difflib import get_close_matches
+from textblob import TextBlob
+from nltk.tokenize import word_tokenize, sent_tokenize
+import nltk
+import ast  
+from urllib.parse import quote
+
+def force_download_nltk():
+    needed_packages = ['punkt'] 
+    for package in needed_packages:
+        try:
+            nltk.data.find(f'tokenizers/{package}')
+        except LookupError:
+            print(f"Downloading NLTK package: {package}")
+            nltk.download(package)
+force_download_nltk()
+
+domain_words = {
+    "carb", "carbs", "carbo", "carbohydrate", "carbohydrates",
+    "fat", "fats", "protein", "proteins", "fiber", "cholesterol",
+    "calcium", "iron", "magnesium", "potassium", "sodium", "vitamin", "vitamin c",
+    "calories", "calorie"
+}
+
+def smart_correct_spelling(text, domain_set):
+    tokens = word_tokenize(text)
+    corrected_tokens = []
+    for token in tokens:
+        if token.isalpha() and token.lower() not in domain_set:
+            corrected_word = str(TextBlob(token).correct())
+            corrected_tokens.append(corrected_word)
+        else:
+            corrected_tokens.append(token)
+    return " ".join(corrected_tokens)
+
+qa_pipeline = pipeline("question-answering", model="distilbert-base-cased-distilled-squad")
+classifier = pipeline("zero-shot-classification", model="facebook/bart-large-mnli")
+summarizer = pipeline("summarization", model="facebook/bart-large-cnn")
+
+def summarize_input(text):
+    summary = summarizer(text, max_length=130, min_length=30, do_sample=False)
+    return summary[0]['summary_text']
+
+df = pd.read_csv(r"Datasets\Final used Datasets\food_dataset_with_nutriition.csv")
+print(f"Starting with {len(df)} recipes in dataset")
+nutrition_columns = ["calories", "Total fats", "Carbohydrate", "Fiber", "Protein", 
+                     "Cholesterol", "Calcium", "Iron", "Magnesium", "Potassium", "Sodium", "Vitamin C"]
+for col in nutrition_columns:
+    df[col] = pd.to_numeric(df[col], errors='coerce')
+
+disease_df = pd.read_csv(r"Datasets\Final used Datasets\disease_food_nutrition_mapping.csv")
+disease_df["Disease"] = disease_df["Disease"].str.lower()
+
+try:
+    with open(r"docs\common_misspellings.json", "r") as file:
+        common_misspellings = json.load(file)
+except FileNotFoundError:
+    common_misspellings = {"suger": "sugar", "milc": "milk"}
+    with open(r"docs\common_misspellings.json", "w") as file:
+        json.dump(common_misspellings, file, indent=2)
+
+try:
+    with open(r"docs\common_ingredients.json", "r") as file:
+        common_ingredients = json.load(file)
+except FileNotFoundError:
+    common_ingredients = ["sugar", "salt", "flour", "milk", "eggs", "butter", "oil", "water"]
+    with open(r"docs\common_ingredients.json", "w") as file:
+        json.dump(common_ingredients, file, indent=2)
+
+def create_ingredient_dictionary(dataframe, common_ingredients_list):
+    all_ingredients = []
+    all_ingredients.extend(common_ingredients_list)
+    all_ingredients.extend(set(common_misspellings.values()))
+    for ingredients_list in dataframe['ingredients']:
+        parts = re.split(r',|\sand\s|\sor\s|;', str(ingredients_list))
+        for part in parts:
+            clean_part = re.sub(
+                r'\d+[\s/]*(oz|ounce|cup|tbsp|tsp|tablespoon|teaspoon|pound|lb|g|ml|l|pinch|dash)\b\.?',
+                '', part)
+            clean_part = re.sub(
+                r'\b(fresh|freshly|chopped|minced|diced|sliced|grated|ground|powdered|crushed|toasted|roasted)\b',
+                '', clean_part)
+            clean_part = re.sub(r'\(.*?\)', '', clean_part)
+            clean_part = clean_part.strip()
+            subparts = re.split(r'\sand\s|\sor\s', clean_part)
+            for subpart in subparts:
+                cleaned_subpart = subpart.strip().lower()
+                if cleaned_subpart and len(cleaned_subpart) > 2:
+                    all_ingredients.append(cleaned_subpart)
+    unique_ingredients = list(set(all_ingredients))
+    unique_ingredients.sort(key=len, reverse=True)
+    return unique_ingredients
+food_dictionary = create_ingredient_dictionary(df, common_ingredients)
+
+def identify_food_ingredient(text, ingredient_dict, misspellings_dict):
+    cleaned = re.sub(
+        r'\d+[\s/]*(oz|ounce|cup|tbsp|tsp|tablespoon|teaspoon|pound|lb|g|ml|l|pinch|dash)\b\.?',
+        '', text)
+    cleaned = re.sub(
+        r'\b(fresh|freshly|chopped|minced|diced|sliced|grated|ground|powdered|crushed|toasted|roasted)\b',
+        '', cleaned)
+    cleaned = re.sub(r'\(.*?\)', '', cleaned)
+    cleaned = cleaned.strip().lower()
+    if cleaned in misspellings_dict:
+        return misspellings_dict[cleaned]
+    if cleaned in ingredient_dict:
+        return cleaned
+    words = cleaned.split()
+    for word in words:
+        if word in ingredient_dict:
+            return word
+        if word in misspellings_dict:
+            return misspellings_dict[word]
+    close_matches = get_close_matches(cleaned, ingredient_dict, n=3, cutoff=0.8)
+    if close_matches:
+        return close_matches[0]
+    for dict_ingredient in ingredient_dict:
+        if dict_ingredient in cleaned:
+            return dict_ingredient
+    close_matches = get_close_matches(cleaned, ingredient_dict, n=3, cutoff=0.6)
+    if close_matches:
+        return close_matches[0]
+    return None
+
+def correct_food_ingredient(ingredient, ingredient_dict, misspellings_dict):
+    cleaned = re.sub(
+        r'\d+[\s/]*(oz|ounce|cup|tbsp|tsp|tablespoon|teaspoon|pound|lb|g|ml|l|pinch|dash)\b\.?',
+        '', ingredient)
+    cleaned = re.sub(
+        r'\b(fresh|freshly|chopped|minced|diced|sliced|grated|ground|powdered|crushed|toasted|roasted)\b',
+        '', cleaned)
+    cleaned = re.sub(r'\(.*?\)', '', cleaned)
+    cleaned = cleaned.strip().lower()
+    if cleaned in misspellings_dict:
+        return misspellings_dict[cleaned]
+    if cleaned in ingredient_dict:
+        return cleaned
+    close_matches = get_close_matches(cleaned, ingredient_dict, n=3, cutoff=0.8)
+    if close_matches:
+        return close_matches[0]
+    close_matches = get_close_matches(cleaned, ingredient_dict, n=3, cutoff=0.6)
+    if close_matches:
+        return close_matches[0]
+    for dict_ingredient in ingredient_dict:
+        if cleaned in dict_ingredient or dict_ingredient in cleaned:
+            return dict_ingredient
+    return cleaned
+
+def add_misspelling(misspelled, correct):
+    try:
+        with open(r"docs\common_misspellings.json", "r") as file:
+            misspellings = json.load(file)
+        misspellings[misspelled.lower()] = correct.lower()
+        with open(r"docs\common_misspellings.json", "w") as file:
+            json.dump(misspellings, file, indent=2, sort_keys=True)
+        return True
+    except Exception:
+        return False
+
+def extract_unwanted_ingredients(input_text):
+    question = "What ingredients should be excluded?"
+    result = qa_pipeline(question=question, context=input_text)
+    raw_answer = result['answer']
+    potential_ingredients = []
+    for part in raw_answer.split(','):
+        for subpart in part.split(' and '):
+            for item in subpart.split(' or '):
+                clean_item = item.strip()
+                if clean_item:
+                    potential_ingredients.append(clean_item)
+    valid_ingredients = []
+    for item in potential_ingredients:
+        corrected = identify_food_ingredient(item, food_dictionary, common_misspellings)
+        if corrected:
+            valid_ingredients.append(corrected)
+    return valid_ingredients if valid_ingredients else [raw_answer]
+
+def classify_clause(clause):
+    candidate_labels = ["include", "exclude"]
+    result = classifier(clause, candidate_labels, hypothesis_template="This clause means the ingredient should be {}.")
+    return result["labels"][0].lower()
+
+def extract_ingredients_from_clause(clause, ingredient_dict, misspellings_dict):
+    found = []
+    for ingredient in ingredient_dict:
+        if ingredient.lower() in clause.lower():
+            normalized = identify_food_ingredient(ingredient, ingredient_dict, misspellings_dict)
+            if normalized:
+                found.append(normalized)
+    return list(set(found))
+
+def classify_ingredients_in_query(query, ingredient_dict, misspellings_dict):
+    include_ingredients = []
+    exclude_ingredients = []
+    
+    nutrition_terms = ['calories', 'calorie', 'fat', 'fats', 'carb', 'carbs', 'protein', 
+                       'fiber', 'cholesterol', 'calcium', 'iron', 'magnesium', 
+                       'potassium', 'sodium', 'vitamin']
+    modified_query = query
+    for term in nutrition_terms:
+        pattern = re.compile(r'(low|high)\s+' + term, re.IGNORECASE)
+        modified_query = pattern.sub('', modified_query)
+    clauses = re.split(r'\bbut\b|,', modified_query, flags=re.IGNORECASE)
+    for clause in clauses:
+        clause = clause.strip()
+        if not clause:
+            continue
+        intent = classify_clause(clause)
+        ingredients_found = extract_ingredients_from_clause(clause, ingredient_dict, misspellings_dict)
+        if intent == "include":
+            include_ingredients.extend(ingredients_found)
+        elif intent == "exclude":
+            exclude_ingredients.extend(ingredients_found)
+    return list(set(include_ingredients)), list(set(exclude_ingredients))
+
+def extract_nutrition_from_clause(clause, nutrition_dict, misspellings_dict):
+    found = []
+    clause_lower = clause.lower()
+    sorted_terms = sorted(nutrition_dict, key=lambda x: -len(x))
+    for term in sorted_terms:
+        pattern = r'\b' + re.escape(term.lower()) + r'\b'
+        if re.search(pattern, clause_lower):
+            found.append(term.lower())
+    return list(set(found))
+
+def classify_nutrition_in_query(query, nutrition_dict, misspellings_dict):
+    include_nutrition = []
+    exclude_nutrition = []
+    clauses = re.split(r'\band\b|,|but', query, flags=re.IGNORECASE)
+    overall_intent = "exclude" if re.search(r'sensitivity|allergy|exclude', query, flags=re.IGNORECASE) else "include"
+    for clause in clauses:
+        clause = clause.strip()
+        if not clause:
+            continue
+        intent = "include" if "i want" in clause.lower() else overall_intent
+        numbers = re.findall(r'\d+(?:\.\d+)?', clause)
+        threshold = float(numbers[0]) if numbers else None
+        if re.search(r'\b(high|over|above|more than|exceeding)\b', clause, flags=re.IGNORECASE):
+            modifier = "high"
+        elif re.search(r'\b(low|under|less than|below)\b', clause, flags=re.IGNORECASE):
+            modifier = "low"
+        else:
+            modifier = "high" if intent == "exclude" else "low"
+        terms_found = extract_nutrition_from_clause(clause, nutrition_dict, misspellings_dict)
+        for term in terms_found:
+            norm_term = nutrition_terms_dictionary.get(term, term)
+            condition = (modifier, norm_term, threshold) if threshold is not None else (modifier, norm_term)
+            if intent == "include":
+                include_nutrition.append(condition)
+            elif intent == "exclude":
+                exclude_nutrition.append(condition)
+    return list(set(include_nutrition)), list(set(exclude_nutrition))
+
+nutrition_terms_dictionary = {
+    "calorie": "calories",
+    "calories": "calories",
+    "fat": "Total fats",
+    "fats": "Total fats",
+    "total fat": "Total fats",
+    "total fats": "Total fats",
+    "carb": "Carbohydrate",
+    "carbs": "Carbohydrate",
+    "carbo": "Carbohydrate",
+    "carbohydrate": "Carbohydrate",
+    "carbohydrates": "Carbohydrate",
+    "fiber": "Fiber",
+    "protein": "Protein",
+    "proteins": "Protein",
+    "cholesterol": "Cholesterol",
+    "calcium": "Calcium",
+    "iron": "Iron",
+    "magnesium": "Magnesium",
+    "potassium": "Potassium",
+    "sodium": "Sodium",
+    "vitamin c": "Vitamin C"
+}
+
+fixed_thresholds = {
+    "calories": 700,
+    "Total fats": 60,
+    "Carbohydrate": 120,
+    "Fiber": 10,
+    "Protein": 30,
+    "Cholesterol": 100,
+    "Calcium": 300,
+    "Iron": 5,
+    "Magnesium": 100,
+    "Potassium": 300,
+    "Sodium": 400,
+    "Vitamin C": 50
+}
+
+def filter_by_nutrition_condition(df, condition):
+    if isinstance(condition, tuple):
+        if len(condition) == 3:
+            direction, nutrition_term, threshold = condition
+        elif len(condition) == 2:
+            direction, nutrition_term = condition
+            threshold = fixed_thresholds.get(nutrition_term)
+        else:
+            return df
+        column = nutrition_term
+        if column is None or threshold is None:
+            return df
+        if direction == "low":
+            return df[df[column] < threshold]
+        elif direction == "high":
+            return df[df[column] >= threshold]
+    return df
+
+def score_recipe_ingredients(recipe_ingredients, include_list):
+    recipe_lower = recipe_ingredients.lower()
+    match_count = sum(
+        1 for ingredient in include_list 
+        if ingredient.lower() in recipe_lower
+    )
+    return match_count
+
+def filter_and_rank_recipes(df, include_list, exclude_list, include_nutrition, exclude_nutrition):
+    filtered_df = df.copy()
+    print(f"Starting with {len(filtered_df)} recipes for filtering")
+    if include_list:
+        filtered_df['ingredient_match_count'] = filtered_df['ingredients'].apply(
+            lambda x: score_recipe_ingredients(str(x), include_list)
+        )
+        filtered_df = filtered_df[filtered_df['ingredient_match_count'] >= 2]
+        print(f"After requiring at least 2 included ingredients: {len(filtered_df)} recipes remain")
+    for ingredient in exclude_list:
+        before_count = len(filtered_df)
+        filtered_df = filtered_df[
+            ~filtered_df['ingredients']
+            .str.lower()
+            .fillna('')
+            .str.contains(re.escape(ingredient.lower()))
+        ]
+        print(f"After excluding '{ingredient}': {len(filtered_df)} recipes remain (removed {before_count - len(filtered_df)})")
+    for i, cond in enumerate(include_nutrition):
+        before_count = len(filtered_df)
+        filtered_df = filter_by_nutrition_condition(filtered_df, cond)
+        after_count = len(filtered_df)
+        print(f"After applying nutrition condition {i+1} (include) '{cond}': {after_count} recipes remain (removed {before_count - after_count})")
+    for i, cond in enumerate(exclude_nutrition):
+        before_count = len(filtered_df)
+        temp_df = filter_by_nutrition_condition(df.copy(), cond)
+        filtered_df = filtered_df[~filtered_df.index.isin(temp_df.index)]
+        after_count = len(filtered_df)
+        print(f"After applying nutrition condition {i+1} (exclude) '{cond}': {after_count} recipes remain (removed {before_count - after_count})")
+    if filtered_df.empty:
+        print("\nNo recipes match all criteria. Implementing fallback approach...")
+        fallback_df = df.copy()
+        if include_list:
+            fallback_df['ingredient_match_count'] = fallback_df['ingredients'].apply(
+                lambda x: score_recipe_ingredients(str(x), include_list)
+            )
+            fallback_df = fallback_df[fallback_df['ingredient_match_count'] >= 1]
+        else:
+            fallback_df['ingredient_match_count'] = 1
+        for ingredient in exclude_list:
+            fallback_df = fallback_df[
+                ~fallback_df['ingredients']
+                .str.lower()
+                .fillna('')
+                .str.contains(re.escape(ingredient.lower()))
+            ]
+        if fallback_df.empty:
+            fallback_df = df.sample(min(5, len(df)))
+            fallback_df['ingredient_match_count'] = 0
+            print("No matches found. Showing random recipes as a fallback")
+        filtered_df = fallback_df
+    if 'ingredient_match_count' not in filtered_df.columns:
+        filtered_df['ingredient_match_count'] = 0
+    filtered_df = filtered_df.sort_values('ingredient_match_count', ascending=False)
+    return filtered_df
+
+def get_disease_recommendations(user_text, disease_mapping_df):
+    user_text_lower = user_text.lower()
+    matches = disease_mapping_df[disease_mapping_df['Disease'].apply(lambda d: d in user_text_lower)]
+    if not matches.empty:
+        disease_info = matches.iloc[0]
+        def safe_parse_list(x):
+            if isinstance(x, str):
+                try:
+                    return ast.literal_eval(x)
+                except:
+                    return [item.strip() for item in x.split(',') if item.strip()]
+            return x
+        best_foods = safe_parse_list(disease_info.get("Best_Foods", "[]"))
+        worst_foods = safe_parse_list(disease_info.get("Worst_Foods", "[]"))
+        best_nutrition = safe_parse_list(disease_info.get("Best_Nutrition", "[]"))
+        worst_nutrition = safe_parse_list(disease_info.get("Worst_Nutrition", "[]"))
+        recommendations = {
+            "Disease": disease_info['Disease'],
+            "Best_Foods": best_foods,
+            "Worst_Foods": worst_foods,
+            "Best_Nutrition": best_nutrition,
+            "Worst_Nutrition": worst_nutrition
+        }
+        return recommendations
+    return None
+
+def get_recipe_output(recipe_row):
+    recipe_name = recipe_row['title']
+    ner_info = recipe_row.get('NER', '')
+    try:
+        ner_list = json.loads(ner_info)
+        ner_str = ", ".join(ner_list)
+    except Exception:
+        ner_str = ner_info
+    nutrition_details = {col: float(recipe_row[col]) for col in nutrition_columns}
+    result = {
+        "Meal name": recipe_name,
+        "NER": ner_str,
+        "Nutrition details": nutrition_details
+    }
+    print(f"Meal name: {recipe_name}")
+    print(f"NER: {ner_str}")
+    print(f"Nutrition details: {nutrition_details}")
+    return result
+
+def process_long_query(query):
+    if len(query.split()) > 500:
+        print("Long input detected. Summarizing...")
+        query = summarize_input(query)
+    print(f"Processed Query: \"{query}\"")
+    corrected = smart_correct_spelling(query, domain_words)
+    sentences = sent_tokenize(corrected)
+    aggregated_include = []
+    aggregated_exclude = []
+    aggregated_include_nutrition = []
+    aggregated_exclude_nutrition = []
+    for sentence in sentences:
+        inc, exc = classify_ingredients_in_query(sentence, food_dictionary, common_misspellings)
+        aggregated_include.extend(inc)
+        aggregated_exclude.extend(exc)
+        inc_nut, exc_nut = classify_nutrition_in_query(sentence, list(nutrition_terms_dictionary.keys()), common_misspellings)
+        aggregated_include_nutrition.extend(inc_nut)
+        aggregated_exclude_nutrition.extend(exc_nut)
+    return corrected, list(set(aggregated_include)), list(set(aggregated_exclude)), \
+           list(set(aggregated_include_nutrition)), list(set(aggregated_exclude_nutrition))
+
+def send_to_api(meal_data, parent_id):
+    try:
+        api_endpoint = "http://54.242.19.19:3000/api/ResturantMenu/add"
+        meal_id = random.randint(1000, 9999)
+        meal_name = meal_data.get("Meal name", "No meal name available")
+        ner_info = meal_data.get("NER", "")
+        images_public = "https://kero.beshoy.me/recipe_images/"
+        image_path = True
+        image_url = ""
+        if image_path:
+            try:
+                image_url = images_public + quote(meal_name, safe="") + ".jpg"
+                print(f"Successfully uploaded image to the server for {meal_name}: {image_url}")
+            except Exception as cl_err:
+                print(f"Error uploading to the server: {cl_err}")
+        if not image_url:
+            image_url = "https://picsum.photos/200"
+        payload = {
+            "id": str(meal_id),
+            "name": meal_name,
+            "description": ner_info,
+            "photo": image_url,
+            "parentId": parent_id
+        }
+        print(f"\nSending payload to API: {payload}")
+        response = requests.post(api_endpoint, json=payload)
+        print(f"API Response for meal {meal_name}: {response.status_code}")
+
+        try:
+            return response.json()
+        except Exception:
+            return {"error": response.text}
+    except Exception as e:
+        print(f"Error sending meal to API: {e}")
+        return {"error": str(e)}
+
+app = Flask(__name__)
+@app.route('/process', methods=['POST'])
+def process():
+    try:
+
+        input_text = ""
+        parent_id = ""
+
+        if request.is_json:
+
+            data = request.json
+            input_text = data.get("description", "")
+            parent_id = data.get("parentId", "")
+            
+            if not input_text:
+                return jsonify({"error": "Missing description in request"}), 400
+            if not parent_id:
+                return jsonify({"error": "Missing parentId in request"}), 400
+
+        else:
+
+            input_text_json = request.form
+            input_text = input_text_json.get("description", "")
+            parent_id = input_text_json.get("parentId", "")
+            
+            if not input_text:
+                return jsonify({"error": "Missing description in request"}), 400
+            if not parent_id:
+                return jsonify({"error": "Missing parentId in request"}), 400
+
+            print("WARNING: Using raw data format. Please consider using JSON format.")
+
+        raw_input_text = input_text
+        processed_input, user_include, user_exclude, user_include_nutrition, user_exclude_nutrition = process_long_query(raw_input_text)
+        
+        include_list, exclude_list = [], []
+        include_nutrition, exclude_nutrition = [], []
+        
+        disease_recs = get_disease_recommendations(processed_input, disease_df)
+        
+        if disease_recs:
+            print("\nDisease-related Recommendations Detected:")
+            print(f"Disease: {disease_recs['Disease']}")
+            print(f"Best Foods: {disease_recs['Best_Foods']}")
+            print(f"Worst Foods: {disease_recs['Worst_Foods']}")
+            print(f"Best Nutrition: {disease_recs['Best_Nutrition']}")
+            print(f"Worst Nutrition: {disease_recs['Worst_Nutrition']}")
+            
+            include_list.extend(disease_recs["Best_Foods"])
+            exclude_list.extend(disease_recs["Worst_Foods"])
+
+            def parse_nutrition_condition(nutrition_phrase):
+                parts = nutrition_phrase.strip().split()
+                if len(parts) == 2:
+                    direction = parts[0].lower()
+                    nutrient = parts[1].lower()
+                    mapped_nutrient = nutrition_terms_dictionary.get(nutrient, nutrient)
+                    return (direction, mapped_nutrient)
+                return None
+
+            for bn in disease_recs["Best_Nutrition"]:
+                cond = parse_nutrition_condition(bn)
+                if cond:
+                    include_nutrition.append(cond)
+            for wn in disease_recs["Worst_Nutrition"]:
+                cond = parse_nutrition_condition(wn)
+                if cond:
+                    exclude_nutrition.append(cond)
+
+        include_list.extend(user_include)
+        exclude_list.extend(user_exclude)
+        include_nutrition.extend(user_include_nutrition)
+        exclude_nutrition.extend(user_exclude_nutrition)
+        
+        include_list = list(set(include_list))
+        exclude_list = list(set(exclude_list))
+        include_nutrition = list(set(include_nutrition))
+        exclude_nutrition = list(set(exclude_nutrition))
+
+        print("\nFinal Lists After Combining Disease + User Query:")
+        print(f"Ingredients to include: {include_list}")
+        print(f"Ingredients to exclude: {exclude_list}")
+        print(f"Nutrition conditions to include: {include_nutrition}")
+        print(f"Nutrition conditions to exclude: {exclude_nutrition}")
+
+        corrected_include = [correct_food_ingredient(ingredient, food_dictionary, common_misspellings) for ingredient in include_list]
+        corrected_exclude = [correct_food_ingredient(ingredient, food_dictionary, common_misspellings) for ingredient in exclude_list]
+
+        include_list = list(set(corrected_include))
+        exclude_list = list(set(corrected_exclude))
+        filtered_df = filter_and_rank_recipes(
+            df, 
+            include_list, 
+            exclude_list, 
+            include_nutrition, 
+            exclude_nutrition
+        )
+        
+        final_output = {}
+        api_responses = []
+        
+        if not filtered_df.empty:
+            filtered_df = filtered_df.sample(frac=1)
+            meal_count = min(6, len(filtered_df))
+            
+            for i in range(meal_count):
+                if i == 0:
+                    print("\nRecommended Meal:")
+                    meal_data = get_recipe_output(filtered_df.iloc[i])
+                    final_output["Recommended Meal"] = meal_data
+                else:
+                    print(f"\nOption {i}:")
+                    meal_data = get_recipe_output(filtered_df.iloc[i])
+                    final_output[f"Option {i}"] = meal_data
+                
+                api_response = send_to_api(meal_data, parent_id)
+                api_responses.append(api_response)
+        else:
+            error_message = f"No recipes found that match your criteria.\nIngredients to include: {', '.join(include_list)}\nIngredients to exclude: {', '.join(exclude_list)}\nNutrition Include: {', '.join(str(cond) for cond in include_nutrition)}\nNutrition Exclude: {', '.join(str(cond) for cond in exclude_nutrition)}."
+            print(error_message)
+            final_output["Message"] = error_message
+            return jsonify({"error": error_message}), 404
+        
+        return jsonify({
+            "original_response": final_output,
+            "api_responses": api_responses,
+            "message": f"Successfully processed {len(api_responses)} meals"
+        })
+    
+    except Exception as e:
+        print(f"Error processing request: {str(e)}")
+        return jsonify({"error": f"Internal server error: {str(e)}"}), 500
+
+
+if __name__ == '__main__':
+    port = int(os.environ.get("PORT", 7860))
+    app.run(host="0.0.0.0", port=port, debug=False)

docs/common_ingredients.json

@@ -0,0 +1,68 @@
+[
+  "sugar", "salt", "flour", "milk", "eggs", "butter", "oil", "water", "garlic", "onion", 
+  "tomato", "cheese", "chicken", "beef", "pork", "rice", "pasta", "potato", "carrot", "celery", 
+  "pepper", "cinnamon", "vanilla", "chocolate", "nuts", "almonds", "peanuts", "wheat", "gluten", "soy",
+  "corn", "fish", "shellfish", "shrimp", "crab", "lobster", "coconut", "banana", "apple", "orange",
+  "lemon", "lime", "strawberry", "blueberry", "raspberry", "blackberry", "honey", "maple syrup", "mustard", "ketchup",
+  "mayonnaise", "vinegar", "wine", "beer", "basil", "oregano", "thyme", "rosemary", "parsley", "cilantro",
+  "mint", "cumin", "paprika", "ginger", "turmeric", "avocado", "broccoli", "cauliflower", "spinach", "kale",
+  "lettuce", "cucumber", "zucchini", "eggplant", "mushroom", "bacon", "ham", "sausage", "turkey", "lamb",
+  "tofu", "beans", "lentils", "chickpeas", "quinoa", "oats", "barley", "yogurt", "cream", "cream cheese",
+  "sour cream", "cheddar", "mozzarella", "parmesan", "olive oil", "vegetable oil", "canola oil", "coconut oil", 
+  "sesame oil", "baking powder", "baking soda", "yeast", "brown sugar", "powdered sugar", "confectioners sugar",
+  "cane sugar", "granulated sugar", "molasses", "agave", "stevia", "honey", "corn syrup", "almond milk",
+  "soy milk", "oat milk", "coconut milk", "cashew milk", "heavy cream", "half and half", "buttermilk",
+  "condensed milk", "evaporated milk", "whole milk", "skim milk", "ricotta", "cottage cheese", "blue cheese",
+  "goat cheese", "feta", "brie", "camembert", "gruyere", "manchego", "gouda", "provolone", "swiss cheese",
+  "pecans", "walnuts", "pistachios", "cashews", "hazelnuts", "macadamia nuts", "peanut butter", "almond butter",
+  "cashew butter", "tahini", "sunflower seeds", "pumpkin seeds", "chia seeds", "flax seeds", "sesame seeds",
+  "poppy seeds", "hemp seeds", "pine nuts", "white rice", "brown rice", "jasmine rice", "basmati rice",
+  "arborio rice", "wild rice", "sushi rice", "wheat flour", "all-purpose flour", "bread flour", "cake flour",
+  "pastry flour", "whole wheat flour", "almond flour", "coconut flour", "rice flour", "semolina", "cornmeal",
+  "corn flour", "tapioca flour", "potato starch", "cornstarch", "arrowroot", "black pepper", "white pepper",
+  "cayenne pepper", "red pepper flakes", "chili powder", "curry powder", "cardamom", "cloves", "nutmeg",
+  "allspice", "star anise", "bay leaf", "saffron", "fennel", "coriander", "mustard seeds", "anise",
+  "tarragon", "dill", "chives", "sage", "marjoram", "lemongrass", "black beans", "kidney beans", "pinto beans",
+  "navy beans", "lima beans", "fava beans", "green beans", "chickpeas", "split peas", "black-eyed peas",
+  "edamame", "mung beans", "red lentils", "green lentils", "brown lentils", "yellow lentils", "white potatoes",
+  "red potatoes", "sweet potatoes", "russet potatoes", "fingerling potatoes", "yukon gold potatoes", "yams",
+  "cabbage", "red cabbage", "napa cabbage", "brussels sprouts", "bok choy", "asparagus", "artichoke",
+  "bell pepper", "red bell pepper", "green bell pepper", "yellow bell pepper", "jalapeno", "habanero",
+  "serrano", "poblano", "chipotle", "cherry tomatoes", "roma tomatoes", "grape tomatoes", "heirloom tomatoes",
+  "sun-dried tomatoes", "tomato paste", "tomato sauce", "tomato puree", "ketchup", "salsa", "red onion", 
+  "white onion", "yellow onion", "green onion", "scallion", "shallot", "leek", "chive", "pumpkin",
+  "butternut squash", "acorn squash", "spaghetti squash", "delicata squash", "kabocha squash", "radish",
+  "daikon", "turnip", "rutabaga", "beet", "fennel bulb", "jicama", "okra", "corn", "baby corn", "hominy",
+  "apple cider vinegar", "balsamic vinegar", "red wine vinegar", "white wine vinegar", "rice vinegar", 
+  "malt vinegar", "sherry vinegar", "champagne vinegar", "distilled vinegar", "white vinegar", "red wine",
+  "white wine", "rose wine", "champagne", "prosecco", "vodka", "rum", "whiskey", "bourbon", "tequila",
+  "brandy", "cognac", "gin", "vermouth", "sake", "ale", "lager", "stout", "porter", "pilsner",
+  "wheat beer", "cider", "coffee", "espresso", "instant coffee", "green tea", "black tea", "herbal tea",
+  "chai tea", "matcha", "cocoa powder", "dark chocolate", "milk chocolate", "white chocolate", "chocolate chips",
+  "candy", "caramel", "toffee", "marshmallow", "gelatin", "agar agar", "sprinkles", "food coloring", 
+  "vanilla extract", "almond extract", "lemon extract", "mint extract", "orange extract", "rum extract", 
+  "peppermint extract", "coconut extract", "maple extract", "rose water", "orange flower water", "miso",
+  "soy sauce", "tamari", "hoisin sauce", "oyster sauce", "fish sauce", "teriyaki sauce", "sriracha",
+  "tabasco", "worcestershire sauce", "hot sauce", "barbecue sauce", "pizza sauce", "pesto", "hummus",
+  "guacamole", "salsa", "relish", "pickle", "sauerkraut", "kimchi", "olives", "capers", "anchovies",
+  "peaches", "pears", "plums", "cherries", "apricots", "nectarines", "grapes", "watermelon", "cantaloupe",
+  "honeydew", "kiwi", "pomegranate", "mango", "papaya", "pineapple", "passion fruit", "dragon fruit",
+  "raisins", "dried cranberries", "dried apricots", "dried dates", "dried figs", "prunes", "grapefruit", 
+  "cranberries", "gooseberries", "currants", "fig", "durian", "lychee", "star fruit", "persimmon",
+  "ground beef", "ground turkey", "ground chicken", "ground pork", "ground lamb", "steak", "filet mignon",
+  "sirloin", "ribeye", "flank steak", "skirt steak", "brisket", "short ribs", "pork chops", "pork tenderloin",
+  "pork belly", "ham hock", "chicken breast", "chicken thigh", "chicken wing", "chicken leg", "whole chicken",
+  "turkey breast", "turkey leg", "duck", "duck breast", "goose", "lamb chop", "leg of lamb", "rack of lamb",
+  "veal", "liver", "foie gras", "tuna", "salmon", "cod", "haddock", "tilapia", "sea bass", "trout",
+  "halibut", "mackerel", "sardines", "herring", "anchovy", "catfish", "mahi mahi", "swordfish", "squid",
+  "octopus", "clams", "mussels", "oysters", "scallops", "crayfish", "langoustine", "eel", "caviar",
+  "roe", "seaweed", "nori", "kombu", "wakame", "dulse", "hijiki", "macaroni", "spaghetti", "fettuccine",
+  "linguine", "penne", "rigatoni", "farfalle", "orzo", "lasagna", "tortellini", "ravioli", "gnocchi",
+  "couscous", "bulgur", "farro", "polenta", "grits", "croissant", "baguette", "brioche", "sourdough",
+  "rye bread", "pumpernickel", "naan", "pita", "focaccia", "ciabatta", "breadcrumbs", "panko", "crackers",
+  "matzo", "tortilla", "phyllo dough", "puff pastry", "pie crust", "graham cracker", "wonton wrapper",
+  "dumpling wrapper", "egg roll wrapper", "rice paper", "udon", "soba", "ramen", "rice noodles", "egg noodles",
+  "glass noodles", "vermicelli", "fusilli", "rotini", "risotto", "shortening", "lard", "suet", "ghee",
+  "margarine", "mayonnaise", "miracle whip", "gravy", "croutons", "stuffing", "nougat", "zwieback", "custard", 
+  "pudding", "jam", "jelly", "marmalade", "preserves", "compote", "curd", "chutney"
+]

docs/common_misspellings.json

@@ -0,0 +1,454 @@
+{
+  "added sugar or corn syrup": "corn syrup",
+  "advocado": "avocado",
+  "advocados": "avocado",
+  "almond mylk": "almond milk",
+  "almonds": "almond",
+  "and": "candy",
+  "armour lower salt bacon": "\"3 slices armour lower salt bacon\"",
+  "aspargus": "asparagus",
+  "aubergine": "eggplant",
+  "avacado": "avocado",
+  "avacados": "avocado",
+  "avocados": "avocado",
+  "baby pearl tapioca": "\" baby pearl tapioca\"",
+  "baccon": "bacon",
+  "bacn": "bacon",
+  "baking potatoes": "5 baking potatoes\"",
+  "bakon": "bacon",
+  "bannana": "banana",
+  "bannanas": "banana",
+  "basil": "basil",
+  "bazil": "basil",
+  "beaf": "beef",
+  "because": "beans",
+  "beef": "beef",
+  "beens": "beans",
+  "beff": "beef",
+  "bewries": "berries",
+  "bewwies": "berries",
+  "bicarbonate of soda": "baking soda",
+  "blak pepper": "black pepper",
+  "blu berries": "blueberries",
+  "bluberries": "blueberries",
+  "blue beries": "blueberries",
+  "blueberreis": "blueberries",
+  "blueberrys": "blueberries",
+  "blueburys": "blueberries",
+  "boc choi": "bok choy",
+  "bokchoy": "bok choy",
+  "boneless rump": "[\"1 1/ boneless rump\"",
+  "bowtie macaroni": "\"bowtie macaroni\"]",
+  "bracoli": "broccoli",
+  "bread": "bread",
+  "bred": "bread",
+  "brockley": "broccoli",
+  "brocli": "broccoli",
+  "brocoli": "broccoli",
+  "brocolli": "broccoli",
+  "brok": "broccoli",
+  "bromato": "tomato",
+  "brown suger": "brown sugar",
+  "brownie mix": "\"1  pkg. brownie mix\"",
+  "brussel sprouts": "brussels sprouts",
+  "brussell sprouts": "brussels sprouts",
+  "brussels": "mussels",
+  "budr": "butter",
+  "bulgur wheat": "\"1 c. bulgur wheat\"",
+  "buter": "butter",
+  "butr": "butter",
+  "cabij": "cabbage",
+  "cacoa": "cocoa",
+  "calorie": "calories",
+  "camomile": "chamomile",
+  "canned soup": "canned tomato soup\"",
+  "capsicm": "capsicum",
+  "capsikcum": "capsicum",
+  "carb": "crab",
+  "carbs": "capers",
+  "carot": "carrot",
+  "carrats": "carrot",
+  "carrit": "carrot",
+  "carrott": "carrot",
+  "carrts": "carrot",
+  "carumom": "cardamom",
+  "caulflower": "cauliflower",
+  "cayane": "cayenne",
+  "cayanne": "cayenne",
+  "cayene": "cayenne",
+  "cellary": "celery",
+  "cellery": "celery",
+  "center": "\"centers",
+  "chalot": "shallot",
+  "chas": "cheese",
+  "chciken": "chicken",
+  "chease": "cheese",
+  "chedar": "cheddar",
+  "chedar cheese": "cheddar cheese",
+  "cheeze": "cheese",
+  "chekin": "chicken",
+  "cheries": "cherries",
+  "cherys": "cherries",
+  "ches": "cheese",
+  "chese": "cheese",
+  "chesee": "cheese",
+  "chestnuts": "chestnut",
+  "chi peas": "chickpeas",
+  "chic pea": "chickpea",
+  "chic peas": "chickpeas",
+  "chicken drummettes": "\"chicken drummettes\"",
+  "chicken livers": "[\"chicken livers\"",
+  "chiili": "chili",
+  "chiken": "chicken",
+  "chili peppers": "chili pepper",
+  "chilli": "chili",
+  "chilli flakes": "chili flakes",
+  "chilli pepper": "chili pepper",
+  "chipolte": "chipotle",
+  "chipotlay": "chipotle",
+  "chives": "chive",
+  "chli flakes": "chili flakes",
+  "choclate": "chocolate",
+  "choclit": "chocolate",
+  "chocolat": "chocolate",
+  "chocolote": "chocolate",
+  "choklit": "chocolate",
+  "chokolate": "chocolate",
+  "chpd": "chopped",
+  "cider vinegar": "\" cider vinegar\"",
+  "cinammon": "cinnamon",
+  "cinamon": "cinnamon",
+  "cinimin": "cinnamon",
+  "cinimon": "cinnamon",
+  "cinnamin": "cinnamon",
+  "cinquetfoil": "cinquefoil",
+  "clery": "celery",
+  "cocnut": "coconut",
+  "coconut milk": "coconut milk",
+  "coconut millk": "coconut milk",
+  "cocunut": "coconut",
+  "cofee": "coffee",
+  "coffe": "coffee",
+  "cokies": "cookies",
+  "coliflower": "cauliflower",
+  "collander": "colander",
+  "confectionary sugar": "confectioners sugar",
+  "cooking oil": "\"cooking oil",
+  "cornflaur": "cornflour",
+  "corriander": "coriander",
+  "cream of mushroom soup": "cream of mushroom soup\"",
+  "crem": "cream",
+  "crisp": "\"crisp",
+  "crutons": "croutons",
+  "cucomber": "cucumber",
+  "cucumba": "cucumber",
+  "cucumbr": "cucumber",
+  "cucumbra": "cucumber",
+  "cumcumber": "cucumber",
+  "cummin": "cumin",
+  "curied": "curry",
+  "currents": "currants",
+  "cyanne": "cayenne",
+  "dijon mustard": "\"dijon mustard\"",
+  "dill": "dill",
+  "doctor": "octopus",
+  "doritos chips": "\"doritos chips\"",
+  "dry mustard": "dry mustard\"",
+  "egg": "eggs",
+  "egges": "eggs",
+  "egggs": "eggs",
+  "eggplnt": "eggplant",
+  "egs": "eggs",
+  "egz": "eggs",
+  "exra-virgin olive oil": "extra virgin olive oil",
+  "exrtra virgin olive oil": "extra virgin olive oil",
+  "fat": "fat\"",
+  "fats": "oats",
+  "fenel": "fennel",
+  "fennle": "fennel",
+  "fettucine noodles": "[\"fettucine noodles \"",
+  "finna": "fennel",
+  "flor": "flour",
+  "flore": "flour",
+  "flounder": "\"flounder",
+  "flour": "flour",
+  "flower": "flour",
+  "flowers with": "\"flower",
+  "fresh ground black pepper": "black pepper",
+  "fresh mushrooms": "mushrooms",
+  "frozen italian style vegetables": "frozen oriental-style vegetables\"",
+  "galic": "garlic",
+  "garlick": "garlic",
+  "garlicy": "garlic",
+  "garlik": "garlic",
+  "garllic": "garlic",
+  "gelatine": "gelatin",
+  "geletin": "gelatin",
+  "gellatine": "gelatin",
+  "ginjer": "ginger",
+  "gnocci": "gnocchi",
+  "gralic": "garlic",
+  "green beens": "green beans",
+  "green chile enchilada sauce": "\"1 can green enchilada sauce\"",
+  "green chillies": "green chilies\"",
+  "green pepper": "green peppers",
+  "ground beef": "beef",
+  "ground meat": "meat\"",
+  "hareesa": "harissa",
+  "hazel nuts": "hazelnuts",
+  "hazlenuts": "hazelnuts",
+  "hebs": "herbs",
+  "herbes": "herbs",
+  "herbz": "herbs",
+  "high": "thighs",
+  "hony": "honey",
+  "hut": "halibut",
+  "jalepano": "jalapeno",
+  "jalepeno": "jalapeno",
+  "jalepino": "jalapeno",
+  "jalopeno": "jalapeno",
+  "japapeno": "jalapeno",
+  "kale": "kale",
+  "katsup": "ketchup",
+  "ketcup": "ketchup",
+  "ketshup": "ketchup",
+  "ketsup": "ketchup",
+  "ladyfingers": "\"ladyfingers\"]",
+  "large red": "\"1 large red",
+  "leafy greens": "collard greens \"",
+  "lemmon": "lemon",
+  "lemmonds": "lemon",
+  "lemmons": "lemon",
+  "lentills": "lentils",
+  "less than 700 calories per serving": "calories",
+  "lettuice": "lettuce",
+  "lettus": "lettuce",
+  "letuce": "lettuce",
+  "lime": "lime",
+  "lime jell-o": "[\" lime jello\"",
+  "lime juice": "lime juice\"",
+  "limes": "lime",
+  "loin end pork": "[\"4 to  loin end pork\"",
+  "long grain white rice": "\"2 c. long grain white rice\"",
+  "low": "orange flower water",
+  "lower than 20 g of fiber": "lower than  of fiber",
+  "magarine": "margarine",
+  "magerine": "margarine",
+  "majarine": "margarine",
+  "manderine": "mandarin",
+  "mapel": "maple",
+  "mapple": "maple",
+  "margerine": "margarine",
+  "marj": "marjoram",
+  "marjaram": "marjoram",
+  "marjoram": "marjoram",
+  "marjorem": "marjoram",
+  "mayo": "mayonnaise",
+  "mayonaise": "mayonnaise",
+  "mayonaisse": "mayonnaise",
+  "mayonase": "mayonnaise",
+  "mayonese": "mayonnaise",
+  "mayonez": "mayonnaise",
+  "menth": "mint",
+  "miilk": "milk",
+  "milc": "milk",
+  "milks": "milk",
+  "mixed pickling spice": "\" mixed pickling spices\"]",
+  "mlik": "milk",
+  "mlik products": "milk",
+  "molk": "milk",
+  "mollases": "molasses",
+  "mollasses": "molasses",
+  "morton tender quick meat cure": "\"3 tbsp. morton tender quick meat cure\"]",
+  "mozarella": "mozzarella",
+  "mozzarela": "mozzarella",
+  "mozzerella": "mozzarella",
+  "mozzorella": "mozzarella",
+  "mushram": "mushroom",
+  "mushroms": "mushrooms",
+  "mushroomz": "mushrooms",
+  "mushrums": "mushrooms",
+  "must": "mustard",
+  "musterd": "mustard",
+  "my": "\"1 single serving size envelope instant creamy chicken soup mix\"",
+  "notmeg": "nutmeg",
+  "nut meg": "nutmeg",
+  "nutmag": "nutmeg",
+  "ocra": "okra",
+  "oil products": "oil",
+  "oile": "oil",
+  "olif oil": "olive oil",
+  "oliv oil": "olive oil",
+  "oliveoil": "olive oil",
+  "ollives": "olives",
+  "onin": "onion",
+  "onino": "onion",
+  "oninon": "onion",
+  "onions": "onions\"",
+  "onnion": "onion",
+  "onoin": "onion",
+  "oranje": "orange",
+  "oreg": "oregano",
+  "oriental chili sesame oil": "\"1/ oriental chili sesame oil\"",
+  "origano": "oregano",
+  "oring": "orange",
+  "orinj": "orange",
+  "over": "liver",
+  "oyl": "oil",
+  "panchetta": "pancetta",
+  "papreka": "paprika",
+  "paprica": "paprika",
+  "parley flakes": "parsley flakes\"",
+  "parmasean": "parmesan",
+  "parmazan": "parmesan",
+  "parmejan": "parmesan",
+  "parmesan cheese": "parmesan cheese\"",
+  "parmezon": "parmesan",
+  "parsely": "parsley",
+  "parsley": "parsley",
+  "parsli": "parsley",
+  "parsly": "parsley",
+  "patato": "potato",
+  "patatos": "potato",
+  "peans": "peas",
+  "pecan halves": "\"pecan halves\"]",
+  "peer": "pear",
+  "penut": "peanut",
+  "penut butter": "peanut butter",
+  "peper": "pepper",
+  "pepers": "peppers",
+  "peppr": "pepper",
+  "pettitoes": "pig's feet",
+  "pickels": "pickles",
+  "pimienta": "pimiento",
+  "pinaple": "pineapple",
+  "pineaple": "pineapple",
+  "plain yogurt": "plain yogurt\"",
+  "potatoe": "potato",
+  "potatoes": "potatoes\"",
+  "potatos": "potato",
+  "powderd sugar": "powdered sugar",
+  "processed meats": "unprocessed bran\"",
+  "raisens": "raisins",
+  "raisin": "raisin",
+  "rasberries": "raspberries",
+  "rasberry": "raspberry",
+  "rasins": "raisins",
+  "red chili pepper": "\"1 red chili pepper\"",
+  "regular fritos": "regular salt\"",
+  "resins": "raisins",
+  "rhubarbe": "rhubarb",
+  "rhubard": "rhubarb",
+  "rise": "rice",
+  "ro-tel tomatoes": "1 can ro-tel tomatoes",
+  "ruis": "rice",
+  "russet potatoe": "russet potato",
+  "s potatoes": "sweet potatoes",
+  "saffran": "saffron",
+  "saffrin": "saffron",
+  "saffrum": "saffron",
+  "safron": "saffron",
+  "said": "squid",
+  "salad dressing": "salad dressing\"",
+  "salad dressing mix": "salad dressing \"",
+  "sallt": "salt",
+  "sammon": "salmon",
+  "samon": "salmon",
+  "sault": "salt",
+  "saurkraut": "sauerkraut",
+  "sausge": "sausage",
+  "scallions": "scallion",
+  "seame seeds": "sesame seeds",
+  "seshuan pepper": "sichuan pepper",
+  "shalott": "shallot",
+  "shampinon": "mushroom",
+  "shampinyons": "mushrooms",
+  "sigar": "sugar",
+  "sinamon": "cinnamon",
+  "sirrup": "syrup",
+  "sirup": "syrup",
+  "sodium": "medium\"",
+  "soja": "soy",
+  "sojakeim": "soybeans",
+  "solt": "salt",
+  "sowmilk": "soy milk",
+  "soy sce": "soy sauce",
+  "soysauce": "soy sauce",
+  "spageti": "spaghetti",
+  "spagetti": "spaghetti",
+  "spaggeti": "spaghetti",
+  "spaghetii": "spaghetti",
+  "spinach": "spinach",
+  "spinage": "spinach",
+  "spinich": "spinach",
+  "squach": "squash",
+  "sqwash": "squash",
+  "stek": "steak",
+  "stew meat": "stew meat\"",
+  "strawberies": "strawberries",
+  "strawberrys": "strawberries",
+  "strawbery": "strawberry",
+  "strwberries": "strawberries",
+  "suagr": "sugar",
+  "subgr": "sugar",
+  "suger": "sugar",
+  "sugr": "sugar",
+  "sugur": "sugar",
+  "sunflowr seeds": "sunflower seeds",
+  "sweatner": "sweetener",
+  "sweet potatoe": "sweet potato",
+  "sweet potatos": "sweet potatoes",
+  "sweet relish": "\"sweet relish\"",
+  "termaric": "turmeric",
+  "termerick": "turmeric",
+  "termuric": "turmeric",
+  "that": "wheat",
+  "thim": "thyme",
+  "tomaotes": "tomatoes",
+  "tomatoe": "tomato",
+  "tomatoe paste": "tomato paste",
+  "tomatoe sauce": "tomato sauce",
+  "tomatos": "tomato",
+  "tomoatoes": "tomatoes",
+  "tomotoes": "tomato",
+  "tortilla chips": "tortilla chips\"",
+  "tumeric": "turmeric",
+  "tuna": "tuna",
+  "turkey burger": "turkey breast",
+  "turmeric": "turmeric",
+  "tyme": "thyme",
+  "under": "\"flounder",
+  "vagetable oil": "vegetable oil",
+  "vainilla": "vanilla",
+  "vanella": "vanilla",
+  "vanil": "vanilla",
+  "vanila": "vanilla",
+  "vanillin": "vanilla",
+  "vegitable oil": "vegetable oil",
+  "velveeta cheese": "velveeta cheese\"",
+  "venegar": "vinegar",
+  "vinager": "vinegar",
+  "vinaigre": "vinegar",
+  "vinega": "vinegar",
+  "vinger": "vinegar",
+  "vinigar": "vinegar",
+  "vinnegar": "vinegar",
+  "wall nuts": "walnuts",
+  "wallnut": "walnut",
+  "wallnuts": "walnuts",
+  "worscestershire": "worcestershire",
+  "worsestershire": "worcestershire",
+  "worstersire": "worcestershire",
+  "wostershire": "worcestershire",
+  "yeest": "yeast",
+  "yellow pepper": "yellow pepper\"",
+  "yogert": "yogurt",
+  "yoghourt": "yogurt",
+  "yoghurt": "yogurt",
+  "yohurt": "yogurt",
+  "youghurt": "yogurt",
+  "yougurt": "yogurt",
+  "zuccini": "zucchini",
+  "zucini": "zucchini",
+  "zukini": "zucchini"
+}

requirements.txt

@@ -0,0 +1,12 @@
+Flask==3.1.0
+pandas==2.2.3
+transformers==4.29.2
+torch==2.6.0
+torchaudio==2.6.0
+torchvision==0.21.0
+requests==2.32.3
+textblob==0.17.1
+tokenizers==0.13.3
+nltk==3.8.1
+asttokens==3.0.0
+urllib3==2.3.0