Update app.py

app.py

@@ -1,6 +1,6 @@
 import gradio as gr
 from ultralytics import YOLO
-import PIL.Image
+from PIL import Image
 import numpy as np
 from typing import List, Tuple, Dict, Optional
 from huggingface_hub import InferenceClient
@@ -183,9 +183,9 @@ def detect_ingredients(images: List, state: Dict) -> Tuple[Dict, List, str]:
         # YOLO returns BGR, convert to RGB
         if len(result_image.shape) == 3:
             result_image_rgb = result_image[..., ::-1]  # BGR to RGB
-            processed_images.append(PIL.Image.fromarray(result_image_rgb))
+            processed_images.append(Image.fromarray(result_image_rgb))
         else:
-            processed_images.append(PIL.Image.fromarray(result_image))
+            processed_images.append(Image.fromarray(result_image))
     
     # Create formatted ingredient list
     if all_detected_items:
@@ -208,27 +208,32 @@ def detect_ingredients(images: List, state: Dict) -> Tuple[Dict, List, str]:
 
 def generate_recipes(cuisine_preference: Optional[str], state: Dict) -> Tuple[Dict, str]:
     """
-    Generate recipes using LLM based on user profile and detected ingredients.
+    Generate recipes using LLM. All inputs are optional with smart defaults.
     """
-    # 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.**"
+    # Make everything optional - use defaults if not provided
+    cuisine_preference = cuisine_preference or "International"
     
-    if not state.get('detected_ingredients'):
-        return state, "**⚠️ Please scan ingredients in the Ingredient Scanner tab first.**"
+    # Get user data with defaults
+    calorie_target = state.get('calorie_target')
+    if calorie_target:
+        calorie_target = int(calorie_target)
+    else:
+        calorie_target = 2000  # Default calorie target
+    
+    goal = state.get('goal', 'Maintain')
+    ingredients = state.get('detected_ingredients', [])
     
-    if not cuisine_preference:
-        return state, "**⚠️ Please select a cuisine preference.**"
+    # Build ingredient list or use default
+    if ingredients:
+        ingredient_list = ", ".join([item.capitalize() for item in ingredients])
+        ingredient_context = f"Use these available ingredients: {ingredient_list}. "
+    else:
+        ingredient_list = "common pantry items"
+        ingredient_context = "Use common, readily available ingredients. "
     
     # 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',
@@ -236,12 +241,12 @@ def generate_recipes(cuisine_preference: Optional[str], state: Dict) -> Tuple[Di
         'Bulking': 'muscle gain with high protein',
         'Custom': 'your custom calorie target'
     }
-    goal_desc = goal_descriptions.get(goal, 'your goals')
+    goal_desc = goal_descriptions.get(goal, 'general health and nutrition')
     
-    # Construct prompt
+    # Construct prompt - flexible based on available data
     prompt = f"""You are a professional nutritionist and chef. Create 3 distinct, detailed recipes that:
 
-1. Use these available ingredients: {ingredient_list}
+1. {ingredient_context}
 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}
@@ -262,7 +267,7 @@ Format each recipe clearly with headers. Make the recipes practical, delicious,
         # Try multiple ways to get the token
         hf_token = None
         
-        # Method 1: Check HF_TOKEN environment variable
+        # Method 1: Check HF_TOKEN environment variable (Hugging Face Spaces secret)
         hf_token = os.getenv("HF_TOKEN", None)
         
         # Method 2: Check HUGGING_FACE_HUB_TOKEN (alternative name)
@@ -277,65 +282,138 @@ Format each recipe clearly with headers. Make the recipes practical, delicious,
             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
-        ]
+        # Initialize client with token if available, otherwise try without
+        # Most models require a token, but we'll try both approaches
+        if hf_token:
+            client = InferenceClient(token=hf_token)
+        else:
+            # Try without token (may not work for most models)
+            client = InferenceClient()
         
+        # Try multiple approaches and models that work on free tier
+        # Strategy: Try chat_completion first (more reliable), then text_generation as fallback
         response = None
         last_error = None
         successful_model = None
+        errors_log = []
+        
+        # List of models to try - simpler models that work on free tier
+        models_to_try = [
+            "microsoft/Phi-3-mini-4k-instruct",
+            "HuggingFaceH4/zephyr-7b-beta", 
+            "mistralai/Mistral-7B-Instruct-v0.2",
+            "meta-llama/Llama-3.2-3B-Instruct",
+            "google/flan-t5-xxl",  # Simple text generation model
+        ]
         
         for model_name in models_to_try:
+            # Try chat_completion first
             try:
+                messages = [
+                    {"role": "system", "content": "You are a professional nutritionist and chef. Create detailed, practical recipes with clear formatting."},
+                    {"role": "user", "content": prompt}
+                ]
+                response_obj = client.chat_completion(
+                    messages=messages,
+                    model=model_name,
+                    max_tokens=1500,
+                    temperature=0.7,
+                )
+                # Extract response
+                if hasattr(response_obj, 'choices') and len(response_obj.choices) > 0:
+                    if hasattr(response_obj.choices[0].message, 'content'):
+                        response = response_obj.choices[0].message.content
+                    else:
+                        response = str(response_obj.choices[0].message)
+                elif isinstance(response_obj, dict) and 'choices' in response_obj:
+                    response = response_obj['choices'][0]['message']['content']
+                elif isinstance(response_obj, str):
+                    response = response_obj
+                else:
+                    response = str(response_obj)
+                
+                if response and len(response.strip()) > 50:  # Make sure we got a real response
+                    successful_model = f"{model_name} (chat_completion)"
+                    break
+            except Exception as chat_error:
+                errors_log.append(f"{model_name} (chat): {str(chat_error)[:80]}")
+                
+                # Try text_generation as fallback for this model
+                try:
+                    response = client.text_generation(
+                        prompt,
+                        model=model_name,
+                        max_new_tokens=1500,
+                        temperature=0.7,
+                    )
+                    if response and len(str(response).strip()) > 50:
+                        successful_model = f"{model_name} (text_generation)"
+                        break
+                except Exception as text_error:
+                    errors_log.append(f"{model_name} (text): {str(text_error)[:80]}")
+                    last_error = text_error
+                    continue
+        
+        # If still no response, try a simple fallback
+        if not response:
+            try:
+                # Try a very simple model as last resort
                 response = client.text_generation(
                     prompt,
-                    model=model_name,
-                    max_new_tokens=1500,
+                    model="gpt2",  # Always available
+                    max_new_tokens=500,
                     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
+                successful_model = "gpt2 (fallback)"
+            except:
+                pass
         
-        # If all models failed, raise error with details
+        # If all models failed, provide helpful error message
         if response is None:
-            error_msg = f"All models failed. Last error: {str(last_error)}"
+            error_msg = f"**⚠️ Failed to generate recipes.**\n\n"
+            
+            # Show last error details
+            if last_error:
+                error_msg += f"**Last error:** {str(last_error)[:200]}\n\n"
+            
+            # Show which models were tried
+            if errors_log:
+                error_msg += "**Models tried:**\n"
+                for err in errors_log[:3]:  # Show first 3 errors
+                    error_msg += f"- {err}\n"
+                error_msg += "\n"
+            
             if not hf_token:
-                error_msg += "\n\n💡 TIP: Make sure you have set your HF_TOKEN environment variable."
-            raise Exception(error_msg)
+                error_msg += """**💡 Setup Required:**
+
+Most recipe generation models require a Hugging Face token.
+
+**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 (get one at https://huggingface.co/settings/tokens)
+6. Click **"Add secret"** and your Space will rebuild automatically
+
+**For Local Development:**
+Set the `HF_TOKEN` environment variable with your Hugging Face token.
+
+Once the token is set, try generating recipes again!"""
+            else:
+                error_msg += """**Possible issues:**
+- The models may require special access (some models need approval on Hugging Face)
+- Your token may not have access to these models (free tier has limitations)
+- Models might be routed to external providers that aren't available
+- Network connectivity issues
+
+**💡 Solutions:**
+1. Make sure your HF_TOKEN has "Inference" permission enabled
+2. Some models require accepting terms on their Hugging Face page first
+3. Try again - models may be temporarily unavailable
+4. Check https://huggingface.co/settings/tokens to verify token permissions"""
+            
+            return state, error_msg
         
         # Extract text if response is a formatted object
         if hasattr(response, 'generated_text'):
@@ -345,12 +423,21 @@ Get your token at: https://huggingface.co/settings/tokens"""
         else:
             response_text = str(response)
         
+        # Build profile summary (only show if data exists)
+        profile_parts = []
+        if state.get('calorie_target'):
+            profile_parts.append(f"- Daily Calorie Target: {calorie_target} calories")
+        if state.get('goal'):
+            profile_parts.append(f"- Goal: {goal}")
+        if ingredients:
+            profile_parts.append(f"- Available Ingredients: {ingredient_list}")
+        
+        profile_summary = "\n".join(profile_parts) if profile_parts else "- Using default settings (2000 calories, general recipes)"
+        
         recipes_text = f"""## 🍳 Recipe Suggestions for {cuisine_preference} Cuisine
 
-**Your Profile:**
-- Daily Calorie Target: {calorie_target} calories
-- Goal: {goal}
-- Available Ingredients: {ingredient_list}
+**Settings Used:**
+{profile_summary}
 
 ---
 
@@ -358,7 +445,7 @@ Get your token at: https://huggingface.co/settings/tokens"""
 
 ---
 
-*Recipes generated based on your profile and available ingredients.*"""
+*Recipes generated using AI. {"Based on your profile and ingredients." if (state.get('calorie_target') or ingredients) else "Feel free to customize your profile and scan ingredients for more personalized results!"}*"""
         
         return state, recipes_text
         
@@ -642,8 +729,8 @@ with gr.Blocks(css=custom_css, theme=gr.themes.Soft()) as demo:
                 """
                 <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.
+                Generate AI-powered recipes! You can customize with your calorie target, fitness goals, and detected ingredients, 
+                or simply select a cuisine preference to get started right away. Everything is optional!
                 </div>
                 """
             )
@@ -652,9 +739,9 @@ with gr.Blocks(css=custom_css, theme=gr.themes.Soft()) as demo:
                 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"
+                        choices=["International", "Mexican", "Chinese", "American", "Italian", "Indian", "Japanese", "Mediterranean", "Thai", "French"],
+                        value="International",
+                        info="Select your preferred cuisine style (optional, defaults to International)"
                     )
                     
                     generate_btn = gr.Button(
@@ -666,10 +753,12 @@ with gr.Blocks(css=custom_css, theme=gr.themes.Soft()) as demo:
                     gr.Markdown("---")
                     gr.Markdown(
                         """
-                        **📝 Requirements:**
-                        - Complete User Profile & Goals tab
-                        - Scan ingredients in Ingredient Scanner tab
-                        - Select a cuisine preference
+                        **📝 Optional Enhancements:**
+                        - 💡 Complete User Profile & Goals tab for personalized calorie targets
+                        - 📸 Scan ingredients in Ingredient Scanner tab for custom recipes
+                        - 🎨 Select a cuisine preference above (defaults to International)
+                        
+                        **✨ You can generate recipes right now with just a cuisine selection!**
                         """
                     )
                 
@@ -698,3 +787,4 @@ with gr.Blocks(css=custom_css, theme=gr.themes.Soft()) as demo:
 # Launch the app
 if __name__ == "__main__":
     demo.launch()
+