Update app.py

app.py

@@ -4,427 +4,232 @@ import numpy as np
 from sklearn.metrics.pairwise import cosine_similarity
 from datasets import load_dataset
 import warnings
+import matplotlib.pyplot as plt
 warnings.filterwarnings('ignore')
 
-# Load the Indian food dataset from Hugging Face
-# Note: You need to be logged in to Hugging Face to access this dataset
-# Run this in a separate cell first: `huggingface-cli login`
+# Load the Indian food dataset or use fallback data
 try:
     ds = load_dataset("Anupam007/nutarian-Indianfood")
-    # Convert the dataset to a pandas DataFrame
     food_df = pd.DataFrame(ds['train'])
-    print(f"Successfully loaded the dataset with {len(food_df)} items")
+    print(f"Successfully loaded dataset with {len(food_df)} items")
     
-    # Display the first few rows to understand the structure
-    print("Dataset columns:", food_df.columns.tolist())
-    
-    # Clean and prepare the dataset
-    # Assuming the dataset has columns like name, calories, protein, carbs, fat, etc.
-    # Adjust these column names based on the actual dataset structure
+    # Clean and prepare dataset
     required_columns = ['name', 'calories', 'protein', 'carbohydrates', 'fat']
-    
-    # Display sample of the data to see what we're working with
-    print(food_df.head())
-    
-    # Rename columns if necessary to match our application's expectations
-    # This is a placeholder - adjust based on actual column names
-    column_mapping = {
-        'Name': 'name',
-        'Calories': 'calories',
-        'Protein': 'protein',
-        'Carbs': 'carbohydrates',
-        'Fats': 'fat',
-        'Category': 'food_group'
-    }
-    
-    # Apply the mapping for columns that exist
+    column_mapping = {'Name': 'name', 'Calories': 'calories', 'Protein': 'protein', 
+                      'Carbs': 'carbohydrates', 'Fats': 'fat', 'Category': 'food_group'}
     for old_col, new_col in column_mapping.items():
         if old_col in food_df.columns:
             food_df = food_df.rename(columns={old_col: new_col})
-    
-    # Add a default serving size if not present
     if 'serving_size' not in food_df.columns:
-        food_df['serving_size'] = 100  # Default serving in grams
-    
-    # Ensure numeric columns are properly typed
+        food_df['serving_size'] = 100
     numeric_cols = ['calories', 'protein', 'carbohydrates', 'fat', 'serving_size']
     for col in numeric_cols:
         if col in food_df.columns:
             food_df[col] = pd.to_numeric(food_df[col], errors='coerce')
-    
-    # Handle any missing values
     food_df = food_df.dropna(subset=['name', 'calories'])
-    
-    print(f"Prepared dataset with {len(food_df)} items")
-    
 except Exception as e:
-    print(f"Error loading dataset: {e}")
-    print("Falling back to sample data...")
-    
-    # Create a sample Indian food database with nutritional information as fallback
+    print(f"Error loading dataset: {e}, using fallback data...")
     food_data = {
-        'name': [
-            'Aloo Gobi', 'Butter Chicken', 'Chana Masala', 'Dal Makhani', 'Palak Paneer',
-            'Roti', 'Naan', 'Basmati Rice', 'Idli', 'Dosa',
-            'Sambar', 'Raita', 'Biryani', 'Tandoori Chicken', 'Vada',
-            'Uttapam', 'Upma', 'Poha', 'Pav Bhaji', 'Chole Bhature'
-        ],
-        'calories': [
-            150, 325, 180, 230, 190,
-            120, 260, 150, 58, 133,
-            152, 75, 292, 165, 97,
-            188, 185, 270, 210, 427
-        ],
-        'protein': [
-            3.5, 28, 7.5, 9, 11,
-            3, 9, 3.5, 2, 3.7,
-            3.8, 3.5, 9.5, 31, 2.2,
-            5.3, 3.5, 5.2, 6, 13.2
-        ],
-        'carbohydrates': [
-            15, 10, 30, 31, 6,
-            18, 33, 32, 12, 25.2,
-            28, 3.5, 46, 0, 16.3,
-            28.5, 31, 44, 22.7, 57.2
-        ],
-        'fat': [
-            8, 17, 6, 9, 12.5,
-            3.7, 11, 0.5, 0.2, 3.8,
-            5.6, 5, 9, 3.6, 3.9,
-            7.2, 7, 12, 12, 20
-        ],
-        'serving_size': [
-            100, 100, 100, 100, 100,
-            30, 80, 100, 40, 100,
-            100, 100, 100, 100, 35,
-            100, 100, 100, 100, 120
-        ],
-        'food_group': [
-            'Vegetable', 'Protein', 'Protein', 'Protein', 'Protein',
-            'Grain', 'Grain', 'Grain', 'Grain', 'Grain',
-            'Vegetable', 'Dairy', 'Mixed', 'Protein', 'Snack',
-            'Grain', 'Grain', 'Grain', 'Mixed', 'Mixed'
-        ]
+        'name': ['Aloo Gobi', 'Butter Chicken', 'Chana Masala', 'Dal Makhani', 'Palak Paneer',
+                 'Roti', 'Naan', 'Basmati Rice', 'Idli', 'Dosa', 'Sambar', 'Raita', 'Biryani',
+                 'Tandoori Chicken', 'Vada', 'Uttapam', 'Upma', 'Poha', 'Pav Bhaji', 'Chole Bhature'],
+        'calories': [150, 325, 180, 230, 190, 120, 260, 150, 58, 133, 152, 75, 292, 165, 97, 
+                     188, 185, 270, 210, 427],
+        'protein': [3.5, 28, 7.5, 9, 11, 3, 9, 3.5, 2, 3.7, 3.8, 3.5, 9.5, 31, 2.2, 
+                    5.3, 3.5, 5.2, 6, 13.2],
+        'carbohydrates': [15, 10, 30, 31, 6, 18, 33, 32, 12, 25.2, 28, 3.5, 46, 0, 16.3, 
+                          28.5, 31, 44, 22.7, 57.2],
+        'fat': [8, 17, 6, 9, 12.5, 3.7, 11, 0.5, 0.2, 3.8, 5.6, 5, 9, 3.6, 3.9, 
+                7.2, 7, 12, 12, 20],
+        'serving_size': [100, 100, 100, 100, 100, 30, 80, 100, 40, 100, 100, 100, 100, 100, 35, 
+                         100, 100, 100, 100, 120],
+        'food_group': ['Vegetable', 'Protein', 'Protein', 'Protein', 'Protein', 'Grain', 'Grain', 
+                       'Grain', 'Grain', 'Grain', 'Vegetable', 'Dairy', 'Mixed', 'Protein', 'Snack',
+                       'Grain', 'Grain', 'Grain', 'Mixed', 'Mixed']
     }
-    
-    # Convert to DataFrame
     food_df = pd.DataFrame(food_data)
-    print(f"Created fallback dataset with {len(food_df)} items")
 
-# Function to calculate daily caloric needs based on Harris-Benedict Equation
+# Sample recipe database (could be expanded)
+recipes = {
+    'Aloo Gobi': "Ingredients: Potatoes, Cauliflower, Spices\nInstructions: Sauté spices, add veggies, cook until tender.",
+    'Butter Chicken': "Ingredients: Chicken, Butter, Cream, Spices\nInstructions: Marinate chicken, cook with sauce.",
+    'Idli': "Ingredients: Rice, Urad Dal\nInstructions: Ferment batter, steam in molds."
+}
+
+# Calculate caloric needs (Harris-Benedict Equation)
 def calculate_caloric_needs(weight, height, age, gender, activity_level):
+    if not all(isinstance(x, (int, float)) and x > 0 for x in [weight, height, age]):
+        raise gr.Error("Weight, height, and age must be positive numbers")
     if gender.lower() == 'male':
         bmr = 88.362 + (13.397 * weight) + (4.799 * height) - (5.677 * age)
     else:
         bmr = 447.593 + (9.247 * weight) + (3.098 * height) - (4.330 * age)
-    
-    activity_multipliers = {
-        'sedentary': 1.2,
-        'lightly active': 1.375,
-        'moderately active': 1.55,
-        'very active': 1.725,
-        'extra active': 1.9
-    }
-    
+    activity_multipliers = {'sedentary': 1.2, 'lightly active': 1.375, 'moderately active': 1.55, 
+                            'very active': 1.725, 'extra active': 1.9}
     return round(bmr * activity_multipliers[activity_level.lower()])
 
-# Function to calculate macronutrient distribution based on goals
+# Calculate macronutrients
 def calculate_macros(caloric_needs, goal):
     macros = {}
-    
     if goal.lower() == 'weight loss':
-        caloric_needs = caloric_needs * 0.85  # 15% deficit
-        macros['protein'] = (caloric_needs * 0.30) / 4  # 30% protein
-        macros['fat'] = (caloric_needs * 0.30) / 9     # 30% fat
-        macros['carbs'] = (caloric_needs * 0.40) / 4   # 40% carbs
-    
+        caloric_needs = caloric_needs * 0.85
+        macros['protein'] = (caloric_needs * 0.30) / 4
+        macros['fat'] = (caloric_needs * 0.30) / 9
+        macros['carbs'] = (caloric_needs * 0.40) / 4
     elif goal.lower() == 'maintenance':
-        macros['protein'] = (caloric_needs * 0.25) / 4  # 25% protein
-        macros['fat'] = (caloric_needs * 0.30) / 9     # 30% fat
-        macros['carbs'] = (caloric_needs * 0.45) / 4   # 45% carbs
-    
+        macros['protein'] = (caloric_needs * 0.25) / 4
+        macros['fat'] = (caloric_needs * 0.30) / 9
+        macros['carbs'] = (caloric_needs * 0.45) / 4
     elif goal.lower() == 'muscle gain':
-        caloric_needs = caloric_needs * 1.10  # 10% surplus
-        macros['protein'] = (caloric_needs * 0.30) / 4  # 30% protein
-        macros['fat'] = (caloric_needs * 0.25) / 9     # 25% fat
-        macros['carbs'] = (caloric_needs * 0.45) / 4   # 45% carbs
-        
-    return {
-        'calories': round(caloric_needs),
-        'protein': round(macros['protein']),
-        'carbs': round(macros['carbs']),
-        'fat': round(macros['fat'])
-    }
+        caloric_needs = caloric_needs * 1.10
+        macros['protein'] = (caloric_needs * 0.30) / 4
+        macros['fat'] = (caloric_needs * 0.25) / 9
+        macros['carbs'] = (caloric_needs * 0.45) / 4
+    return {'calories': round(caloric_needs), 'protein': round(macros['protein']), 
+            'carbs': round(macros['carbs']), 'fat': round(macros['fat'])}
 
-# Function to recommend Indian meals based on nutritional requirements and preferences
+# Recommend meals
 def recommend_meals(caloric_needs, macros, restrictions, meals_per_day, meal_preferences):
-    """
-    Generate Indian meal recommendations based on user's nutritional needs
-    """
-    # Filter foods based on dietary restrictions
     filtered_foods = food_df.copy()
-    
     if 'vegetarian' in restrictions:
-        if 'food_group' in filtered_foods.columns:
-            filtered_foods = filtered_foods[~filtered_foods['food_group'].str.contains('Non-veg|Meat', 
-                                                                                      case=False, 
-                                                                                      na=False)]
+        filtered_foods = filtered_foods[~filtered_foods['food_group'].str.contains('Non-veg|Meat', case=False, na=False)]
     if 'vegan' in restrictions:
-        if 'food_group' in filtered_foods.columns:
-            filtered_foods = filtered_foods[~filtered_foods['food_group'].str.contains('Non-veg|Meat|Dairy', 
-                                                                                      case=False, 
-                                                                                      na=False)]
-    
-    # Apply meal preferences (North Indian, South Indian, etc.)
-    if meal_preferences and 'region' in filtered_foods.columns:
-        if meal_preferences != "All":
-            filtered_foods = filtered_foods[filtered_foods['region'].str.contains(meal_preferences, 
-                                                                                 case=False, 
-                                                                                 na=False)]
-    
-    # If we've filtered too aggressively, reset to the original dataset
+        filtered_foods = filtered_foods[~filtered_foods['food_group'].str.contains('Non-veg|Meat|Dairy', case=False, na=False)]
     if len(filtered_foods) < 10:
         filtered_foods = food_df.copy()
-        print("Warning: Too many filters applied, using complete dataset")
-    
-    # Determine typical meal patterns for Indian cuisine
-    meal_types = {
-        "Breakfast": ["Idli", "Dosa", "Poha", "Upma", "Paratha", "Uttapam"],
-        "Lunch": ["Rice", "Dal", "Curry", "Roti", "Sabzi", "Biryani"],
-        "Dinner": ["Roti", "Sabzi", "Curry", "Rice", "Dal"],
-        "Snack": ["Vada", "Samosa", "Dhokla", "Chaat"]
-    }
     
-    # Determine per-meal nutritional targets
+    meal_types = {"Breakfast": ["Idli", "Dosa", "Poha", "Upma"], "Lunch": ["Rice", "Dal", "Roti", "Biryani"],
+                  "Dinner": ["Roti", "Sabzi", "Dal"], "Snack": ["Vada", "Samosa"]}
     per_meal_calories = caloric_needs / meals_per_day
-    per_meal_protein = macros['protein'] / meals_per_day
-    per_meal_carbs = macros['carbs'] / meals_per_day
-    per_meal_fat = macros['fat'] / meals_per_day
-    
-    # Create meal plans
     meal_plan = []
-    daily_meal_names = ["Breakfast", "Lunch", "Evening Snack", "Dinner"]
-    
-    # Make sure we don't exceed the number of meal names we have
+    daily_meal_names = ["Breakfast", "Lunch", "Evening Snack", "Dinner"][:meals_per_day]
     if meals_per_day > len(daily_meal_names):
-        for i in range(len(daily_meal_names), meals_per_day):
-            daily_meal_names.append(f"Meal {i+1}")
-    
-    # Select meal names based on meals_per_day
-    selected_meal_names = daily_meal_names[:meals_per_day]
+        daily_meal_names.extend([f"Meal {i+1}" for i in range(len(daily_meal_names), meals_per_day)])
     
-    # For each meal, select foods that roughly match the macros
-    for meal_num, meal_name in enumerate(selected_meal_names):
-        # Determine meal type
-        if "Breakfast" in meal_name:
-            meal_category = "Breakfast"
-        elif "Lunch" in meal_name:
-            meal_category = "Lunch"
-        elif "Dinner" in meal_name:
-            meal_category = "Dinner"
-        elif "Snack" in meal_name:
-            meal_category = "Snack"
-        else:
-            meal_category = "Lunch"  # Default to lunch for other meals
-        
-        # Select 2-4 items that together meet the nutritional requirements
-        selected_items = []
-        current_nutrition = {'calories': 0, 'protein': 0, 'carbs': 0, 'fat': 0}
-        
-        # Try to find food items that correspond to the meal type
-        if 'name' in filtered_foods.columns and meal_types.get(meal_category):
-            potential_items = filtered_foods[filtered_foods['name'].str.contains('|'.join(meal_types[meal_category]), 
-                                                                              case=False, 
-                                                                              na=False)]
-        else:
-            # If we can't filter by meal type, just sample from all foods
-            potential_items = filtered_foods
-        
-        # If too few items match, use the full dataset
+    for meal_name in daily_meal_names:
+        meal_category = next((k for k, v in meal_types.items() if meal_name in k), "Lunch")
+        potential_items = filtered_foods[filtered_foods['name'].str.contains('|'.join(meal_types.get(meal_category, [])), 
+                                                                            case=False, na=False)] if meal_types.get(meal_category) else filtered_foods
         if len(potential_items) < 5:
             potential_items = filtered_foods
-        
-        # Randomly select 2-4 items
         num_items = np.random.randint(2, 5)
-        if len(potential_items) < num_items:
-            selected_food_items = potential_items.sample(frac=1)
-        else:
-            selected_food_items = potential_items.sample(num_items)
+        selected_food_items = potential_items.sample(min(num_items, len(potential_items)))
         
-        # Calculate total nutrition from selected items
+        selected_items = []
+        current_nutrition = {'calories': 0, 'protein': 0, 'carbs': 0, 'fat': 0}
         for _, food in selected_food_items.iterrows():
-            # Adjust serving size to meet caloric target
-            base_calories = food.get('calories', 0)
-            if base_calories == 0:
-                continue
-                
-            # Start with a reasonable serving size
             serving_multiplier = 1.0
-            
-            # Add to the meal plan
-            food_name = food.get('name', "Unknown Food")
+            food_name = food.get('name', "Unknown")
             serving_size = food.get('serving_size', 100) * serving_multiplier
-            
-            # Calculate nutrition
             item_calories = food.get('calories', 0) * serving_multiplier
             item_protein = food.get('protein', 0) * serving_multiplier
             item_carbs = food.get('carbohydrates', 0) * serving_multiplier
             item_fat = food.get('fat', 0) * serving_multiplier
-            
             current_nutrition['calories'] += item_calories
             current_nutrition['protein'] += item_protein
             current_nutrition['carbs'] += item_carbs
             current_nutrition['fat'] += item_fat
-            
-            selected_items.append({
-                'name': food_name,
-                'serving': round(serving_size),
-                'calories': item_calories,
-                'protein': item_protein,
-                'carbs': item_carbs,
-                'fat': item_fat
-            })
+            selected_items.append({'name': food_name, 'serving': round(serving_size), 'calories': item_calories, 
+                                   'protein': item_protein, 'carbs': item_carbs, 'fat': item_fat})
         
-        # Scale all servings to meet the calorie target
         if current_nutrition['calories'] > 0:
             scaling_factor = per_meal_calories / current_nutrition['calories']
-            
-            # Apply scaling to all selected items
             for item in selected_items:
                 item['serving'] = round(item['serving'] * scaling_factor)
                 item['calories'] = item['calories'] * scaling_factor
                 item['protein'] = item['protein'] * scaling_factor
                 item['carbs'] = item['carbs'] * scaling_factor
                 item['fat'] = item['fat'] * scaling_factor
-            
-            current_nutrition = {
-                'calories': sum(item['calories'] for item in selected_items),
-                'protein': sum(item['protein'] for item in selected_items),
-                'carbs': sum(item['carbs'] for item in selected_items),
-                'fat': sum(item['fat'] for item in selected_items)
-            }
+            current_nutrition = {k: sum(item[k] for item in selected_items) for k in ['calories', 'protein', 'carbs', 'fat']}
         
-        # Create the meal plan entry
-        meal_plan.append({
-            'name': meal_name,
-            'items': selected_items,
-            'nutrition': {
-                'calories': round(current_nutrition['calories']),
-                'protein': round(current_nutrition['protein']),
-                'carbs': round(current_nutrition['carbs']),
-                'fat': round(current_nutrition['fat'])
-            }
-        })
-    
+        meal_plan.append({'name': meal_name, 'items': selected_items, 
+                          'nutrition': {k: round(v) for k, v in current_nutrition.items()}})
     return meal_plan
 
-# Function to format the meal plan output
+# Format meal plan with recipes
 def format_meal_plan(meal_plan, daily_targets):
-    output = "# Your Personalized Indian Cuisine Nutrition Plan\n\n"
-    
-    output += "## Daily Nutritional Targets\n"
-    output += f"- Calories: {daily_targets['calories']} kcal\n"
-    output += f"- Protein: {daily_targets['protein']}g\n"
-    output += f"- Carbohydrates: {daily_targets['carbs']}g\n"
-    output += f"- Fats: {daily_targets['fat']}g\n\n"
-    
-    output += "## Meal Plan\n\n"
-    
+    output = "# Your Personalized Indian Meal Plan\n\n"
+    output += f"## Daily Targets: {daily_targets['calories']} kcal, {daily_targets['protein']}g protein, {daily_targets['carbs']}g carbs, {daily_targets['fat']}g fat\n\n"
     total_nutrition = {'calories': 0, 'protein': 0, 'carbs': 0, 'fat': 0}
     
     for meal in meal_plan:
         output += f"### {meal['name']}\n"
         for item in meal['items']:
             output += f"- {item['name']} ({item['serving']}g) - {round(item['calories'])} kcal\n"
-        
+            if item['name'] in recipes:
+                output += f"  *Recipe*: {recipes[item['name']]}\n"
         nutrition = meal['nutrition']
-        total_nutrition['calories'] += nutrition['calories']
-        total_nutrition['protein'] += nutrition['protein']
-        total_nutrition['carbs'] += nutrition['carbs']
-        total_nutrition['fat'] += nutrition['fat']
-        
-        output += f"\n**Meal Nutrition:** {nutrition['calories']} kcal, {nutrition['protein']}g protein, "
-        output += f"{nutrition['carbs']}g carbs, {nutrition['fat']}g fats\n\n"
-    
-    output += "## Daily Nutrition Summary\n"
-    output += f"- Total Calories: {total_nutrition['calories']} kcal (Target: {daily_targets['calories']} kcal)\n"
-    output += f"- Total Protein: {total_nutrition['protein']}g (Target: {daily_targets['protein']}g)\n"
-    output += f"- Total Carbs: {total_nutrition['carbs']}g (Target: {daily_targets['carbs']}g)\n"
-    output += f"- Total Fats: {total_nutrition['fat']}g (Target: {daily_targets['fat']}g)\n"
-    
-    # Add some healthy eating tips for Indian cuisine
-    output += "\n## Healthy Indian Eating Tips\n"
-    output += "1. **Portion Control**: Traditional Indian thalis often contain a balanced variety of foods in moderate portions\n"
-    output += "2. **Cooking Methods**: Opt for steaming, roasting, or baking instead of deep frying\n"
-    output += "3. **Spice Benefits**: Many Indian spices like turmeric, cumin, and coriander have health benefits\n"
-    output += "4. **Vegetable Variety**: Include a wide variety of vegetables in your diet\n"
-    output += "5. **Whole Grains**: Choose whole grain options like brown rice, whole wheat roti, or millet\n"
+        total_nutrition = {k: total_nutrition[k] + v for k, v in nutrition.items()}
+        output += f"\n**Nutrition:** {nutrition['calories']} kcal, {nutrition['protein']}g protein, {nutrition['carbs']}g carbs, {nutrition['fat']}g fat\n\n"
     
+    output += f"## Summary: {total_nutrition['calories']} kcal, {total_nutrition['protein']}g protein, {total_nutrition['carbs']}g carbs, {total_nutrition['fat']}g fat\n"
     return output
 
-# Main function to create the nutrition plan
-def create_nutrition_plan(weight, height, age, gender, activity_level, goal, 
-                          dietary_restrictions, meals_per_day, regional_preference):
-    # Calculate caloric needs
+# Main function
+def create_nutrition_plan(weight, height, age, gender, activity_level, goal, dietary_restrictions, meals_per_day, regional_preference):
     caloric_needs = calculate_caloric_needs(weight, height, age, gender, activity_level)
-    
-    # Calculate macronutrient distribution
     macros = calculate_macros(caloric_needs, goal)
-    
-    # Parse dietary restrictions
     restrictions = dietary_restrictions.lower().split(', ') if dietary_restrictions else []
-    
-    # Generate meal recommendations
     meal_plan = recommend_meals(macros['calories'], macros, restrictions, meals_per_day, regional_preference)
-    
-    # Format the meal plan output
-    formatted_plan = format_meal_plan(meal_plan, macros)
-    
-    return formatted_plan
+    return format_meal_plan(meal_plan, macros)
+
+# Progress tracking (simple example)
+progress_data = {'dates': [], 'calories': []}
+def track_progress(calories_consumed):
+    progress_data['dates'].append(pd.Timestamp.now().strftime('%Y-%m-%d'))
+    progress_data['calories'].append(float(calories_consumed))
+    fig, ax = plt.subplots()
+    ax.plot(progress_data['dates'], progress_data['calories'], marker='o')
+    ax.set_xlabel("Date")
+    ax.set_ylabel("Calories Consumed")
+    plt.xticks(rotation=45)
+    return fig
 
-# Create the Gradio interface
-with gr.Blocks(title="Indian Cuisine Nutrition Planner") as app:
-    gr.Markdown("# Indian Cuisine Nutrition Planner")
-    gr.Markdown("Enter your information to get a personalized Indian meal plan")
+# Social sharing
+def share_plan(plan):
+    return f"Check out my Indian Meal Plan!\n\n{plan}"
+
+# Gradio Interface
+with gr.Blocks(theme=gr.themes.Soft(primary_hue="orange", secondary_hue="green"), 
+               css=".gr-button {border-radius: 10px;} .header {color: #FF5733; font-size: 2em;}") as app:
+    gr.Markdown("# Indian Cuisine Nutrition Planner", elem_classes="header")
+    gr.Markdown("Plan your meals with authentic Indian flavors!")
     
     with gr.Row():
-        with gr.Column():
-            # User inputs
+        with gr.Column(scale=1, min_width=300):
             weight = gr.Number(label="Weight (kg)", value=70)
             height = gr.Number(label="Height (cm)", value=170)
             age = gr.Number(label="Age", value=30)
             gender = gr.Radio(["Male", "Female"], label="Gender", value="Male")
-            activity_level = gr.Dropdown(
-                ["Sedentary", "Lightly Active", "Moderately Active", "Very Active", "Extra Active"],
-                label="Activity Level",
-                value="Moderately Active"
-            )
-            goal = gr.Radio(["Weight Loss", "Maintenance", "Muscle Gain"], 
-                            label="Goal", value="Maintenance")
-            dietary_restrictions = gr.Textbox(
-                label="Dietary Restrictions (comma-separated, e.g., vegetarian)",
-                value=""
-            )
-            meals_per_day = gr.Slider(2, 6, value=3, step=1, label="Meals per Day")
-            regional_preference = gr.Dropdown(
-                ["All", "North Indian", "South Indian", "East Indian", "West Indian"],
-                label="Regional Preference",
-                value="All"
-            )
-            
-            submit_btn = gr.Button("Generate Indian Nutrition Plan")
+            activity_level = gr.Dropdown(["Sedentary", "Lightly Active", "Moderately Active", 
+                                        "Very Active", "Extra Active"], label="Activity Level", 
+                                        value="Moderately Active")
         
-        with gr.Column():
-            # Output area
-            output = gr.Markdown()
+        with gr.Column(scale=1, min_width=300):
+            goal = gr.Radio(["Weight Loss", "Maintenance", "Muscle Gain"], label="Goal", value="Maintenance")
+            dietary_restrictions = gr.Textbox(label="Dietary Restrictions (e.g., vegetarian)", value="")
+            meals_per_day = gr.Slider(2, 6, value=3, step=1, label="Meals per Day")
+            regional_preference = gr.Dropdown(["All", "North Indian", "South Indian", "East Indian", 
+                                             "West Indian"], label="Regional Preference", value="All")
+            submit_btn = gr.Button("Generate Plan", variant="primary")
+
+    with gr.Row():
+        output = gr.Markdown(label="Your Meal Plan")
+    
+    with gr.Tab("Track Progress"):
+        calories_input = gr.Number(label="Log Today's Calories")
+        track_btn = gr.Button("Add to Progress")
+        progress_plot = gr.Plot(label="Calorie Progress")
     
-    # Connect the function to the button
-    submit_btn.click(
-        fn=create_nutrition_plan,
-        inputs=[weight, height, age, gender, activity_level, goal, dietary_restrictions, 
-                meals_per_day, regional_preference],
-        outputs=output
-    )
+    with gr.Tab("Share"):
+        share_btn = gr.Button("Generate Shareable Plan")
+        share_output = gr.Textbox(label="Share this with friends!")
+
+    submit_btn.click(fn=create_nutrition_plan, 
+                     inputs=[weight, height, age, gender, activity_level, goal, dietary_restrictions, 
+                             meals_per_day, regional_preference], 
+                     outputs=output)
+    track_btn.click(fn=track_progress, inputs=calories_input, outputs=progress_plot)
+    share_btn.click(fn=share_plan, inputs=output, outputs=share_output)
 
-# Launch the app
 app.launch(debug=True)