Update app.py

app.py

@@ -1,627 +1,627 @@
-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():
-    nltk_data_dir = os.environ.get("NLTK_DATA", "/app/nltk_data")
-    transformers_cache_dir = os.environ.get("TRANSFORMERS_CACHE", "/app/transformers_cache")
-    os.makedirs(nltk_data_dir, exist_ok=True)
-    os.makedirs(transformers_cache_dir, exist_ok=True)
-    os.environ["NLTK_DATA"] = nltk_data_dir
-    os.environ["TRANSFORMERS_CACHE"] = transformers_cache_dir
-    needed_packages = ["punkt"]
-    for package in needed_packages:
-        try:
-            nltk.data.find(f"tokenizers/{package}")
-        except LookupError:
-            print(f"Downloading NLTK package: {package} to {nltk_data_dir}")
-            nltk.download(package, download_dir=nltk_data_dir)
-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)
+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():
+    nltk_data_dir = os.environ.get("NLTK_DATA", "/app/nltk_data")
+    transformers_cache_dir = os.environ.get("TRANSFORMERS_CACHE", "/app/transformers_cache")
+    os.makedirs(nltk_data_dir, exist_ok=True)
+    os.makedirs(transformers_cache_dir, exist_ok=True)
+    os.environ["NLTK_DATA"] = nltk_data_dir
+    os.environ["TRANSFORMERS_CACHE"] = transformers_cache_dir
+    needed_packages = ["punkt"]
+    for package in needed_packages:
+        try:
+            nltk.data.find(f"tokenizers/{package}")
+        except LookupError:
+            print(f"Downloading NLTK package: {package} to {nltk_data_dir}")
+            nltk.download(package, download_dir=nltk_data_dir)
+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("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("Datasets/Final used Datasets/disease_food_nutrition_mapping.csv")
+disease_df["Disease"] = disease_df["Disease"].str.lower()
+
+try:
+    with open("docs/common_misspellings.json", "r") as file:
+        common_misspellings = json.load(file)
+except FileNotFoundError:
+    common_misspellings = {"suger": "sugar", "milc": "milk"}
+    with open("docs/common_misspellings.json", "w") as file:
+        json.dump(common_misspellings, file, indent=2)
+
+try:
+    with open("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("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("docs/common_misspellings.json", "r") as file:
+            misspellings = json.load(file)
+        misspellings[misspelled.lower()] = correct.lower()
+        with open("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)