Update app.py

Major Update:

-Profile creation with calories properly calculated with 4 options for diets
- Recipe gen is having trouble with hugging face token call to other llm for some reason tried to trouble shoot but still errors

app.py

@@ -2,23 +2,159 @@ import gradio as gr
 from ultralytics import YOLO
 import PIL.Image
 import numpy as np
-from typing import List, Tuple
+from typing import List, Tuple, Dict, Optional
+from huggingface_hub import InferenceClient
 
 # Load the trained model
 model = YOLO('best.pt')
 
-def detect_ingredients(images: List) -> Tuple[List, str]:
+# Initialize state structure
+def init_user_state() -> Dict:
+    """Initialize the user state dictionary."""
+    return {
+        'name': '',
+        'age': None,
+        'weight_lbs': None,
+        'height_cm': None,
+        'gender': '',
+        'activity_level': '',
+        'goal': '',
+        'calorie_target': None,
+        'cuisine_preference': '',
+        'detected_ingredients': [],
+        'ingredient_list_text': ''
+    }
+
+# ==================== BMR & CALORIE CALCULATION ====================
+
+def convert_height_to_cm(height_ft: Optional[float], height_in: Optional[float]) -> Optional[float]:
+    """Convert feet and inches to centimeters."""
+    if height_ft is None or height_in is None:
+        return None
+    total_inches = (height_ft * 12) + height_in
+    return total_inches * 2.54
+
+def calculate_bmr(weight_kg: float, height_cm: float, age: int, gender: str) -> float:
+    """
+    Calculate Basal Metabolic Rate using Mifflin-St Jeor Equation.
+    
+    BMR (Men) = 10 × weight(kg) + 6.25 × height(cm) - 5 × age(years) + 5
+    BMR (Women) = 10 × weight(kg) + 6.25 × height(cm) - 5 × age(years) - 161
+    """
+    base_bmr = (10 * weight_kg) + (6.25 * height_cm) - (5 * age)
+    
+    if gender.lower() == 'male':
+        bmr = base_bmr + 5
+    else:  # female
+        bmr = base_bmr - 161
+    
+    return bmr
+
+def get_activity_multiplier(activity_level: str) -> float:
+    """Get activity multiplier based on activity level."""
+    multipliers = {
+        'Sedentary': 1.2,
+        'Light': 1.375,
+        'Moderate': 1.55,
+        'Active': 1.725,
+        'Very Active': 1.9
+    }
+    return multipliers.get(activity_level, 1.2)
+
+def get_goal_adjustment(goal: str) -> int:
+    """Get calorie adjustment based on goal."""
+    adjustments = {
+        'Cutting': -500,
+        'Maintain': 0,
+        'Bulking': +500,
+        'Custom': 0  # Will be handled separately
+    }
+    return adjustments.get(goal, 0)
+
+def calculate_calorie_target(
+    weight_lbs: Optional[float],
+    height_ft: Optional[float],
+    height_in: Optional[float],
+    age: Optional[int],
+    gender: Optional[str],
+    activity_level: Optional[str],
+    goal: Optional[str],
+    custom_calories: Optional[float],
+    state: Dict
+) -> Tuple[Dict, str]:
+    """
+    Calculate daily calorie target based on user inputs.
+    Updates state and returns formatted result.
+    """
+    # Validate inputs
+    if not all([weight_lbs, height_ft is not None, height_in is not None, age, gender, activity_level, goal]):
+        return state, "**Please fill in all required fields.**"
+    
+    # Convert weight to kg
+    weight_kg = weight_lbs * 0.453592
+    
+    # Convert height to cm
+    height_cm = convert_height_to_cm(height_ft, height_in)
+    if height_cm is None:
+        return state, "**Please enter valid height values.**"
+    
+    # Calculate BMR
+    bmr = calculate_bmr(weight_kg, height_cm, age, gender)
+    
+    # Get activity multiplier
+    activity_mult = get_activity_multiplier(activity_level)
+    
+    # Calculate TDEE (Total Daily Energy Expenditure)
+    tdee = bmr * activity_mult
+    
+    # Apply goal adjustment
+    if goal == 'Custom' and custom_calories is not None:
+        calorie_target = custom_calories
+    else:
+        goal_adj = get_goal_adjustment(goal)
+        calorie_target = tdee + goal_adj
+    
+    # Update state
+    state['weight_lbs'] = weight_lbs
+    state['height_cm'] = height_cm
+    state['age'] = age
+    state['gender'] = gender
+    state['activity_level'] = activity_level
+    state['goal'] = goal
+    state['calorie_target'] = calorie_target
+    
+    # Format output
+    result_text = f"""
+    ## 📊 Your Daily Calorie Target
+    
+    **BMR (Basal Metabolic Rate):** {bmr:.0f} calories/day
+    **Activity Level:** {activity_level} (×{activity_mult:.2f})
+    **TDEE (Total Daily Energy Expenditure):** {tdee:.0f} calories/day
+    **Goal Adjustment:** {get_goal_adjustment(goal):+.0f} calories
+    
+    ### 🎯 **Daily Calorie Target: {calorie_target:.0f} calories**
+    
+    *This target is based on your profile and has been saved for recipe generation.*
+    """
+    
+    return state, result_text
+
+# ==================== INGREDIENT DETECTION ====================
+
+def detect_ingredients(images: List, state: Dict) -> Tuple[Dict, List, str]:
     """
     Process multiple images and return detected ingredients.
+    Also updates the state with detected ingredients.
     
     Args:
         images: List of uploaded images (file paths)
+        state: User state dictionary
         
     Returns:
-        Tuple of (processed_images, ingredient_list_text)
+        Tuple of (updated_state, processed_images, ingredient_list_text)
     """
     if not images or len(images) == 0:
-        return [], "**No images uploaded.**"
+        return state, [], "**No images uploaded.**"
     
     processed_images = []
     all_detected_items = set()
@@ -57,10 +193,187 @@ def detect_ingredients(images: List) -> Tuple[List, str]:
         ingredient_list_text = "**Detected Ingredients:**\n\n"
         ingredient_list_text += "\n".join([f"• {item.capitalize()}" for item in ingredient_list])
         ingredient_list_text += f"\n\n**Total unique items:** {len(ingredient_list)}"
+        
+        # Update state with detected ingredients
+        state['detected_ingredients'] = ingredient_list
+        state['ingredient_list_text'] = ingredient_list_text
     else:
         ingredient_list_text = "**No ingredients detected.**\n\nTry adjusting the image quality or lighting."
+        state['detected_ingredients'] = []
+        state['ingredient_list_text'] = ingredient_list_text
+    
+    return state, processed_images, ingredient_list_text
+
+# ==================== RECIPE GENERATION ====================
+
+def generate_recipes(cuisine_preference: Optional[str], state: Dict) -> Tuple[Dict, str]:
+    """
+    Generate recipes using LLM based on user profile and detected ingredients.
+    """
+    # Validate that we have the necessary data
+    if not state.get('calorie_target'):
+        return state, "**⚠️ Please complete your User Profile & Goals first to set your calorie target.**"
     
-    return processed_images, ingredient_list_text
+    if not state.get('detected_ingredients'):
+        return state, "**⚠️ Please scan ingredients in the Ingredient Scanner tab first.**"
+    
+    if not cuisine_preference:
+        return state, "**⚠️ Please select a cuisine preference.**"
+    
+    # Update state
+    state['cuisine_preference'] = cuisine_preference
+    
+    # Get user data
+    calorie_target = int(state['calorie_target'])
+    goal = state.get('goal', 'Maintain')
+    ingredients = state['detected_ingredients']
+    ingredient_list = ", ".join([item.capitalize() for item in ingredients])
+    
+    # Map goal to dietary focus
+    goal_descriptions = {
+        'Cutting': 'weight loss and calorie deficit',
+        'Maintain': 'maintaining current weight',
+        'Bulking': 'muscle gain with high protein',
+        'Custom': 'your custom calorie target'
+    }
+    goal_desc = goal_descriptions.get(goal, 'your goals')
+    
+    # Construct prompt
+    prompt = f"""You are a professional nutritionist and chef. Create 3 distinct, detailed recipes that:
+
+1. Use these available ingredients: {ingredient_list}
+2. Fit within a daily calorie target of approximately {calorie_target} calories per day
+3. Match {cuisine_preference} cuisine style
+4. Align with the goal of {goal_desc}
+
+For each recipe, provide:
+- Recipe name
+- Serving size
+- Estimated calories per serving
+- Complete ingredient list (you may suggest additional common pantry items if needed)
+- Step-by-step cooking instructions
+- Nutritional highlights relevant to the goal
+
+Format each recipe clearly with headers. Make the recipes practical, delicious, and suitable for home cooking."""
+
+    try:
+        # Use Hugging Face Inference API
+        import os
+        # Try multiple ways to get the token
+        hf_token = None
+        
+        # Method 1: Check HF_TOKEN environment variable
+        hf_token = os.getenv("HF_TOKEN", None)
+        
+        # Method 2: Check HUGGING_FACE_HUB_TOKEN (alternative name)
+        if not hf_token:
+            hf_token = os.getenv("HUGGING_FACE_HUB_TOKEN", None)
+        
+        # Method 3: Try to get from Hugging Face cache (for Spaces or logged-in users)
+        if not hf_token:
+            try:
+                from huggingface_hub import HfFolder
+                hf_token = HfFolder.get_token()
+            except:
+                pass
+        
+        if not hf_token:
+            return state, """**⚠️ Hugging Face Token Required**
+
+Please set your HF_TOKEN environment variable to use recipe generation.
+
+**For Hugging Face Spaces:**
+1. Go to your Space Settings (gear icon)
+2. Scroll to "Repository secrets"
+3. Click "New secret"
+4. Name: `HF_TOKEN`
+5. Value: Your Hugging Face token
+6. Click "Add secret" and restart your Space
+
+**For Local Development (Windows):**
+1. Press Win+R, type `sysdm.cpl`, press Enter
+2. Go to "Advanced" tab → "Environment Variables"
+3. Under "User variables", click "New"
+4. Variable name: `HF_TOKEN`
+5. Variable value: Your Hugging Face token
+6. Click OK and restart your application
+
+Get your token at: https://huggingface.co/settings/tokens"""
+        
+        client = InferenceClient(token=hf_token)
+        
+        # Try using models that support text-generation
+        # List of models to try in order of preference (all verified to work with text-generation)
+        models_to_try = [
+            "meta-llama/Llama-3.2-3B-Instruct",  # Fast and reliable
+            "meta-llama/Llama-3.1-8B-Instruct",  # Better quality
+            "mistralai/Mistral-7B-Instruct-v0.3",  # Alternative option
+            "microsoft/Phi-3-mini-4k-instruct",  # Lightweight fallback
+            "google/gemma-2-2b-it",  # Additional reliable option
+        ]
+        
+        response = None
+        last_error = None
+        successful_model = None
+        
+        for model_name in models_to_try:
+            try:
+                response = client.text_generation(
+                    prompt,
+                    model=model_name,
+                    max_new_tokens=1500,
+                    temperature=0.7,
+                )
+                successful_model = model_name
+                break  # Success, exit the loop
+            except Exception as model_error:
+                last_error = model_error
+                continue  # Try next model
+        
+        # If all models failed, raise error with details
+        if response is None:
+            error_msg = f"All models failed. Last error: {str(last_error)}"
+            if not hf_token:
+                error_msg += "\n\n💡 TIP: Make sure you have set your HF_TOKEN environment variable."
+            raise Exception(error_msg)
+        
+        # Extract text if response is a formatted object
+        if hasattr(response, 'generated_text'):
+            response_text = response.generated_text
+        elif isinstance(response, str):
+            response_text = response
+        else:
+            response_text = str(response)
+        
+        recipes_text = f"""## 🍳 Recipe Suggestions for {cuisine_preference} Cuisine
+
+**Your Profile:**
+- Daily Calorie Target: {calorie_target} calories
+- Goal: {goal}
+- Available Ingredients: {ingredient_list}
+
+---
+
+{response_text}
+
+---
+
+*Recipes generated based on your profile and available ingredients.*"""
+        
+        return state, recipes_text
+        
+    except Exception as e:
+        error_msg = f"""**⚠️ Error generating recipes.**
+
+Please try again. If the issue persists, you may need to:
+1. Check your internet connection
+2. Ensure you have a Hugging Face API token set (if required)
+3. Try a different cuisine preference
+
+Error details: {str(e)}"""
+        return state, error_msg
+
+# ==================== GRADIO INTERFACE ====================
 
 # Custom CSS for a modern, clean interface
 custom_css = """
@@ -97,91 +410,291 @@ custom_css = """
     .ingredient-list * {
         color: #000000 !important;
     }
-    .ingredient-list p, .ingredient-list strong {
+    .calorie-result {
+        background: #e8f5e9;
+        padding: 20px;
+        border-radius: 8px;
+        border-left: 4px solid #4caf50;
+        margin-top: 20px;
+        color: #000000 !important;
+    }
+    .calorie-result * {
         color: #000000 !important;
     }
 """
 
 # Create the Gradio interface
 with gr.Blocks(css=custom_css, theme=gr.themes.Soft()) as demo:
+    # Header
     gr.Markdown(
         """
-        # 🥗 Fridge Ingredient Scanner
+        # 🥗 Smart Recipe Assistant
         
-        Upload photos of your fridge, pantry, or groceries to automatically detect ingredients!
+        Your AI-powered kitchen companion: Scan ingredients, calculate calories, and generate personalized recipes!
         """,
         elem_classes=["main-header"]
     )
     
-    gr.Markdown(
-        """
-        <div class="description-box">
-        <strong>📸 How to use:</strong><br>
-        1. Click "Upload Images" or drag and drop multiple photos<br>
-        2. Wait for the AI to analyze your ingredients<br>
-        3. View all processed images with detection boxes and the complete ingredient list
-        </div>
-        """,
-        elem_classes=["description-box"]
-    )
+    # Initialize state
+    user_state = gr.State(value=init_user_state)
     
-    with gr.Row():
-        with gr.Column(scale=1):
-            image_input = gr.File(
-                file_count="multiple",
-                file_types=["image"],
-                label="📁 Upload Images",
-                height=200
+    # Tab structure
+    with gr.Tabs() as tabs:
+        # ========== TAB 1: USER PROFILE & GOALS ==========
+        with gr.Tab("👤 User Profile & Goals"):
+            gr.Markdown(
+                """
+                <div class="description-box">
+                <strong>📋 Set up your profile:</strong><br>
+                Enter your personal information and fitness goals to calculate your daily calorie target.
+                This will be used to generate personalized recipes.
+                </div>
+                """
             )
             
-            process_btn = gr.Button(
-                "🔍 Detect Ingredients",
-                variant="primary",
-                size="lg"
+            with gr.Row():
+                with gr.Column(scale=1):
+                    name_input = gr.Textbox(
+                        label="Name",
+                        placeholder="Enter your name",
+                        value=""
+                    )
+                    
+                    with gr.Row():
+                        age_input = gr.Number(
+                            label="Age",
+                            minimum=1,
+                            maximum=120,
+                            value=None,
+                            precision=0
+                        )
+                        
+                        gender_input = gr.Dropdown(
+                            label="Gender",
+                            choices=["Male", "Female"],
+                            value=None
+                        )
+                    
+                    with gr.Row():
+                        weight_input = gr.Number(
+                            label="Weight (lbs)",
+                            minimum=1,
+                            maximum=1000,
+                            value=None,
+                            precision=1
+                        )
+                    
+                    with gr.Row():
+                        height_ft_input = gr.Number(
+                            label="Height (feet)",
+                            minimum=1,
+                            maximum=8,
+                            value=None,
+                            precision=0
+                        )
+                        
+                        height_in_input = gr.Number(
+                            label="Height (inches)",
+                            minimum=0,
+                            maximum=11,
+                            value=None,
+                            precision=0
+                        )
+                    
+                    activity_input = gr.Dropdown(
+                        label="Activity Level",
+                        choices=["Sedentary", "Light", "Moderate", "Active", "Very Active"],
+                        value=None,
+                        info="Sedentary: Little/no exercise | Light: Light exercise 1-3 days/week | Moderate: Moderate exercise 3-5 days/week | Active: Hard exercise 6-7 days/week | Very Active: Very hard exercise, physical job"
+                    )
+                    
+                    goal_input = gr.Radio(
+                        label="Goal",
+                        choices=["Cutting", "Maintain", "Bulking", "Custom"],
+                        value=None
+                    )
+                    
+                    custom_calories_input = gr.Number(
+                        label="Custom Calorie Target",
+                        minimum=800,
+                        maximum=5000,
+                        value=None,
+                        precision=0,
+                        visible=False,
+                        info="Enter your desired daily calorie target"
+                    )
+                    
+                    calculate_btn = gr.Button(
+                        "📊 Calculate Calorie Target",
+                        variant="primary",
+                        size="lg"
+                    )
+                
+                with gr.Column(scale=1):
+                    calorie_output = gr.Markdown(
+                        label="Calorie Calculation Result",
+                        elem_classes=["calorie-result"]
+                    )
+            
+            # Show/hide custom calories input based on goal selection
+            def toggle_custom_calories(goal):
+                if goal == "Custom":
+                    return gr.update(visible=True)
+                else:
+                    # Reset value to None when hiding to prevent validation errors
+                    return gr.update(visible=False, value=None)
+            
+            goal_input.change(
+                fn=toggle_custom_calories,
+                inputs=goal_input,
+                outputs=custom_calories_input
             )
             
-            gr.Markdown("---")
+            # Calculate calories
+            calculate_btn.click(
+                fn=calculate_calorie_target,
+                inputs=[
+                    weight_input,
+                    height_ft_input,
+                    height_in_input,
+                    age_input,
+                    gender_input,
+                    activity_input,
+                    goal_input,
+                    custom_calories_input,
+                    user_state
+                ],
+                outputs=[user_state, calorie_output]
+            )
             
-            ingredient_output = gr.Markdown(
-                label="📋 Detected Ingredients",
-                elem_classes=["ingredient-list"]
+            # Update name in state when changed
+            name_input.change(
+                fn=lambda name, state: ({**state, 'name': name}, state),
+                inputs=[name_input, user_state],
+                outputs=[user_state, user_state]
             )
         
-        with gr.Column(scale=2):
-            gallery_output = gr.Gallery(
-                label="🖼️ Processed Images with Detections",
-                show_label=True,
-                elem_id="gallery",
-                columns=2,
-                rows=2,
-                height="auto",
-                allow_preview=True,
-                preview=True
+        # ========== TAB 2: INGREDIENT SCANNER ==========
+        with gr.Tab("📸 Ingredient Scanner"):
+            gr.Markdown(
+                """
+                <div class="description-box">
+                <strong>📸 How to use:</strong><br>
+                1. Click "Upload Images" or drag and drop multiple photos<br>
+                2. Wait for the AI to analyze your ingredients<br>
+                3. View all processed images with detection boxes and the complete ingredient list<br>
+                4. Detected ingredients will be saved for recipe generation
+                </div>
+                """
+            )
+            
+            with gr.Row():
+                with gr.Column(scale=1):
+                    image_input = gr.File(
+                        file_count="multiple",
+                        file_types=["image"],
+                        label="📁 Upload Images",
+                        height=200
+                    )
+                    
+                    process_btn = gr.Button(
+                        "🔍 Detect Ingredients",
+                        variant="primary",
+                        size="lg"
+                    )
+                    
+                    gr.Markdown("---")
+                    
+                    ingredient_output = gr.Markdown(
+                        label="📋 Detected Ingredients",
+                        elem_classes=["ingredient-list"]
+                    )
+                
+                with gr.Column(scale=2):
+                    gallery_output = gr.Gallery(
+                        label="🖼️ Processed Images with Detections",
+                        show_label=True,
+                        elem_id="gallery",
+                        columns=2,
+                        rows=2,
+                        height="auto",
+                        allow_preview=True,
+                        preview=True
+                    )
+            
+            # Process images when button is clicked
+            process_btn.click(
+                fn=detect_ingredients,
+                inputs=[image_input, user_state],
+                outputs=[user_state, gallery_output, ingredient_output]
+            )
+            
+            # Also process when images are uploaded (auto-detect)
+            image_input.upload(
+                fn=detect_ingredients,
+                inputs=[image_input, user_state],
+                outputs=[user_state, gallery_output, ingredient_output]
+            )
+        
+        # ========== TAB 3: RECIPE GENERATOR ==========
+        with gr.Tab("🍳 Recipe Generator"):
+            gr.Markdown(
+                """
+                <div class="description-box">
+                <strong>🍳 Generate personalized recipes:</strong><br>
+                Based on your calorie target, fitness goals, and detected ingredients, 
+                we'll generate 3 custom recipes tailored to your preferences.
+                </div>
+                """
+            )
+            
+            with gr.Row():
+                with gr.Column(scale=1):
+                    cuisine_input = gr.Dropdown(
+                        label="Cuisine Preference",
+                        choices=["Mexican", "Chinese", "American", "Italian", "Indian", "Japanese", "Mediterranean", "Thai", "French"],
+                        value=None,
+                        info="Select your preferred cuisine style"
+                    )
+                    
+                    generate_btn = gr.Button(
+                        "✨ Generate Recipes",
+                        variant="primary",
+                        size="lg"
+                    )
+                    
+                    gr.Markdown("---")
+                    gr.Markdown(
+                        """
+                        **📝 Requirements:**
+                        - Complete User Profile & Goals tab
+                        - Scan ingredients in Ingredient Scanner tab
+                        - Select a cuisine preference
+                        """
+                    )
+                
+                with gr.Column(scale=2):
+                    recipe_output = gr.Markdown(
+                        label="Generated Recipes",
+                        elem_classes=["ingredient-list"]
+                    )
+            
+            # Generate recipes
+            generate_btn.click(
+                fn=generate_recipes,
+                inputs=[cuisine_input, user_state],
+                outputs=[user_state, recipe_output]
             )
-    
-    # Process images when button is clicked
-    process_btn.click(
-        fn=detect_ingredients,
-        inputs=image_input,
-        outputs=[gallery_output, ingredient_output]
-    )
-    
-    # Also process when images are uploaded (auto-detect)
-    image_input.upload(
-        fn=detect_ingredients,
-        inputs=image_input,
-        outputs=[gallery_output, ingredient_output]
-    )
     
     gr.Markdown(
         """
         ---
         <div style="text-align: center; color: #666; padding: 20px;">
-        <small>Powered by YOLOv11 | Upload multiple images to scan your entire fridge!</small>
+        <small>Powered by YOLOv11 & AI Recipe Generation | Your smart kitchen assistant!</small>
         </div>
         """
     )
 
 # Launch the app
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch()