Spaces:
Sleeping
Sleeping
| import gradio as gr | |
| import pandas as pd | |
| import datetime | |
| import json | |
| import os | |
| from typing import Dict, List, Tuple | |
| import plotly.graph_objects as go | |
| import plotly.express as px | |
| from dataclasses import dataclass, asdict | |
| import google.generativeai as genai | |
| # Data structure for health records | |
| class HealthRecord: | |
| date: str | |
| morning_mood: int | |
| morning_energy: int | |
| morning_sleep_quality: int | |
| afternoon_water_intake: int | |
| afternoon_physical_activity: int | |
| afternoon_stress_level: int | |
| evening_meal_quality: int | |
| evening_screen_time: int | |
| evening_gratitude: int | |
| daily_score: float | |
| ai_recommendation: str | |
| class AIDoctor: | |
| def __init__(self): | |
| self.data_file = "health_data.json" | |
| self.setup_gemini() | |
| self.load_data() | |
| def setup_gemini(self): | |
| """Setup Google Gemini AI""" | |
| # Get API key from environment variable or Hugging Face Secrets | |
| api_key = os.getenv("GEMINI_API_KEY") or os.getenv("GOOGLE_API_KEY") | |
| if api_key: | |
| genai.configure(api_key=api_key) | |
| self.model = genai.GenerativeModel('gemini-pro') | |
| self.gemini_available = True | |
| else: | |
| self.gemini_available = False | |
| print("⚠️ Gemini API key not found. Using fallback recommendations.") | |
| def load_data(self): | |
| """Load existing health data""" | |
| if os.path.exists(self.data_file): | |
| try: | |
| with open(self.data_file, 'r') as f: | |
| data = json.load(f) | |
| self.records = [HealthRecord(**record) for record in data] | |
| except: | |
| self.records = [] | |
| else: | |
| self.records = [] | |
| def save_data(self): | |
| """Save health data to file""" | |
| try: | |
| with open(self.data_file, 'w') as f: | |
| json.dump([asdict(record) for record in self.records], f, indent=2) | |
| except: | |
| pass | |
| def calculate_daily_score(self, morning_data: Dict, afternoon_data: Dict, evening_data: Dict) -> float: | |
| """Calculate daily health score (0-100)""" | |
| # Morning score (30% weight) | |
| morning_score = ( | |
| morning_data['mood'] * 0.4 + | |
| morning_data['energy'] * 0.4 + | |
| morning_data['sleep_quality'] * 0.2 | |
| ) * 10 | |
| # Afternoon score (40% weight) | |
| afternoon_score = ( | |
| min(morning_data['water_intake'] / 8, 1) * 40 + # 8 glasses target | |
| min(afternoon_data['physical_activity'] / 60, 1) * 40 + # 60 min target | |
| (10 - afternoon_data['stress_level']) * 2 # Lower stress is better | |
| ) | |
| # Evening score (30% weight) | |
| evening_score = ( | |
| evening_data['meal_quality'] * 8 + | |
| max(0, (8 - evening_data['screen_time'])) * 2 + # Less than 8 hours | |
| evening_data['gratitude'] * 10 | |
| ) | |
| # Weighted total | |
| total_score = (morning_score * 0.3 + afternoon_score * 0.4 + evening_score * 0.3) | |
| return min(100, max(0, total_score)) | |
| def generate_ai_recommendation(self, score: float, morning_data: Dict, afternoon_data: Dict, evening_data: Dict) -> str: | |
| """Generate AI doctor recommendations using Gemini""" | |
| if self.gemini_available: | |
| try: | |
| # Create detailed health context for Gemini | |
| health_context = f""" | |
| You are an AI Health Doctor analyzing a patient's daily health data. Provide personalized, actionable health recommendations. | |
| PATIENT DAILY HEALTH DATA: | |
| - Overall Health Score: {score:.1f}/100 | |
| Morning Metrics: | |
| - Mood: {morning_data['mood']}/10 | |
| - Energy Level: {morning_data['energy']}/10 | |
| - Sleep Quality: {morning_data['sleep_quality']}/10 | |
| Afternoon Metrics: | |
| - Water Intake: {morning_data['water_intake']} glasses (target: 8) | |
| - Physical Activity: {afternoon_data['physical_activity']} minutes (target: 60) | |
| - Stress Level: {afternoon_data['stress_level']}/10 (lower is better) | |
| Evening Metrics: | |
| - Meal Quality: {evening_data['meal_quality']}/10 | |
| - Screen Time: {evening_data['screen_time']} hours | |
| - Gratitude Practice: {evening_data['gratitude']}/10 | |
| INSTRUCTIONS: | |
| 1. Analyze the overall health pattern | |
| 2. Identify 2-3 key areas for improvement | |
| 3. Provide specific, actionable recommendations | |
| 4. Use encouraging, doctor-like tone | |
| 5. Include emojis for better engagement | |
| 6. Keep response under 300 words | |
| 7. Focus on the lowest-scoring metrics | |
| Format: Start with overall assessment, then provide specific recommendations for improvement areas. | |
| """ | |
| # Get historical context if available | |
| if len(self.records) >= 3: | |
| recent_scores = [r.daily_score for r in self.records[-3:]] | |
| trend = "improving" if recent_scores[-1] > recent_scores[0] else "declining" if recent_scores[-1] < recent_scores[0] else "stable" | |
| health_context += f"\n\nRecent 3-day trend: {trend} (scores: {recent_scores})" | |
| # Generate response with Gemini | |
| response = self.model.generate_content(health_context) | |
| return response.text | |
| except Exception as e: | |
| print(f"Gemini API error: {e}") | |
| return self.fallback_recommendations(score, morning_data, afternoon_data, evening_data) | |
| else: | |
| return self.fallback_recommendations(score, morning_data, afternoon_data, evening_data) | |
| def fallback_recommendations(self, score: float, morning_data: Dict, afternoon_data: Dict, evening_data: Dict) -> str: | |
| """Fallback recommendations when Gemini is not available""" | |
| recommendations = [] | |
| # Score-based general advice | |
| if score >= 85: | |
| recommendations.append("🌟 Excellent health habits! You're doing amazing!") | |
| elif score >= 70: | |
| recommendations.append("👍 Good health practices! Small improvements can make you even better.") | |
| elif score >= 50: | |
| recommendations.append("⚠️ Moderate health status. Focus on key areas for improvement.") | |
| else: | |
| recommendations.append("🚨 Your health needs attention. Let's work on fundamental habits.") | |
| # Specific recommendations | |
| if morning_data['sleep_quality'] < 6: | |
| recommendations.append("💤 Sleep Quality: Aim for 7-9 hours of sleep. Create a bedtime routine.") | |
| if morning_data['mood'] < 6: | |
| recommendations.append("😊 Mood: Try 10 minutes of meditation or journaling in the morning.") | |
| if morning_data['energy'] < 6: | |
| recommendations.append("⚡ Energy: Consider a protein-rich breakfast and light morning exercise.") | |
| if morning_data['water_intake'] < 6: | |
| recommendations.append("💧 Hydration: Aim for 8 glasses of water daily. Set hourly reminders.") | |
| if afternoon_data['physical_activity'] < 30: | |
| recommendations.append("🏃 Activity: Try to get at least 30 minutes of physical activity daily.") | |
| if afternoon_data['stress_level'] > 7: | |
| recommendations.append("🧘 Stress: Practice deep breathing or take short breaks throughout the day.") | |
| if evening_data['meal_quality'] < 6: | |
| recommendations.append("🥗 Nutrition: Focus on whole foods, vegetables, and balanced meals.") | |
| if evening_data['screen_time'] > 6: | |
| recommendations.append("📱 Screen Time: Reduce screen time before bed for better sleep quality.") | |
| return " | ".join(recommendations) | |
| def morning_checkin(self, mood: int, energy: int, sleep_quality: int, water_goal: int) -> str: | |
| """Process morning check-in""" | |
| today = datetime.date.today().isoformat() | |
| # Store morning data temporarily | |
| self.temp_morning = { | |
| 'mood': mood, | |
| 'energy': energy, | |
| 'sleep_quality': sleep_quality, | |
| 'water_intake': water_goal | |
| } | |
| return f"✅ Morning check-in completed!\n\nMood: {mood}/10\nEnergy: {energy}/10\nSleep Quality: {sleep_quality}/10\nWater Goal: {water_goal} glasses\n\n👉 Complete your afternoon check-in next!" | |
| def afternoon_checkin(self, water_consumed: int, physical_activity: int, stress_level: int) -> str: | |
| """Process afternoon check-in""" | |
| if not hasattr(self, 'temp_morning'): | |
| return "❌ Please complete your morning check-in first!" | |
| self.temp_afternoon = { | |
| 'physical_activity': physical_activity, | |
| 'stress_level': stress_level | |
| } | |
| # Update water intake | |
| self.temp_morning['water_intake'] = water_consumed | |
| return f"✅ Afternoon check-in completed!\n\nWater Consumed: {water_consumed} glasses\nPhysical Activity: {physical_activity} minutes\nStress Level: {stress_level}/10\n\n👉 Complete your evening check-in to get your daily score!" | |
| def evening_checkin(self, meal_quality: int, screen_time: int, gratitude: int) -> Tuple[str, str, object]: | |
| """Process evening check-in and generate daily report""" | |
| if not hasattr(self, 'temp_morning') or not hasattr(self, 'temp_afternoon'): | |
| return "❌ Please complete morning and afternoon check-ins first!", "", None | |
| evening_data = { | |
| 'meal_quality': meal_quality, | |
| 'screen_time': screen_time, | |
| 'gratitude': gratitude | |
| } | |
| # Calculate daily score | |
| score = self.calculate_daily_score(self.temp_morning, self.temp_afternoon, evening_data) | |
| # Generate AI recommendation | |
| recommendation = self.generate_ai_recommendation(score, self.temp_morning, self.temp_afternoon, evening_data) | |
| # Create health record | |
| today = datetime.date.today().isoformat() | |
| record = HealthRecord( | |
| date=today, | |
| morning_mood=self.temp_morning['mood'], | |
| morning_energy=self.temp_morning['energy'], | |
| morning_sleep_quality=self.temp_morning['sleep_quality'], | |
| afternoon_water_intake=self.temp_morning['water_intake'], | |
| afternoon_physical_activity=self.temp_afternoon['physical_activity'], | |
| afternoon_stress_level=self.temp_afternoon['stress_level'], | |
| evening_meal_quality=evening_data['meal_quality'], | |
| evening_screen_time=evening_data['screen_time'], | |
| evening_gratitude=evening_data['gratitude'], | |
| daily_score=score, | |
| ai_recommendation=recommendation | |
| ) | |
| # Save record | |
| self.records = [r for r in self.records if r.date != today] # Remove today's old record | |
| self.records.append(record) | |
| self.save_data() | |
| # Generate report | |
| report = f""" | |
| # 🏥 Daily Health Report - {today} | |
| ## 📊 Your Health Score: {score:.1f}/100 | |
| ### 🌅 Morning Metrics: | |
| - Mood: {self.temp_morning['mood']}/10 | |
| - Energy: {self.temp_morning['energy']}/10 | |
| - Sleep Quality: {self.temp_morning['sleep_quality']}/10 | |
| ### 🌞 Afternoon Metrics: | |
| - Water Intake: {self.temp_morning['water_intake']} glasses | |
| - Physical Activity: {self.temp_afternoon['physical_activity']} minutes | |
| - Stress Level: {self.temp_afternoon['stress_level']}/10 | |
| ### 🌙 Evening Metrics: | |
| - Meal Quality: {evening_data['meal_quality']}/10 | |
| - Screen Time: {evening_data['screen_time']} hours | |
| - Gratitude Practice: {gratitude}/10 | |
| ## 🤖 AI Doctor Recommendations: | |
| {recommendation} | |
| --- | |
| *Keep up the great work! Consistency is key to better health.* 🌟 | |
| """ | |
| # Create progress chart | |
| chart = self.create_progress_chart() | |
| # Clear temporary data | |
| delattr(self, 'temp_morning') | |
| delattr(self, 'temp_afternoon') | |
| return f"✅ Evening check-in completed!", report, chart | |
| def create_progress_chart(self): | |
| """Create progress visualization""" | |
| if len(self.records) < 2: | |
| return None | |
| df = pd.DataFrame([asdict(record) for record in self.records[-7:]]) # Last 7 days | |
| fig = go.Figure() | |
| fig.add_trace(go.Scatter( | |
| x=df['date'], | |
| y=df['daily_score'], | |
| mode='lines+markers', | |
| name='Daily Health Score', | |
| line=dict(color='#2E86AB', width=3), | |
| marker=dict(size=8) | |
| )) | |
| fig.update_layout( | |
| title='📈 Your 7-Day Health Progress', | |
| xaxis_title='Date', | |
| yaxis_title='Health Score', | |
| yaxis=dict(range=[0, 100]), | |
| template='plotly_white', | |
| height=400 | |
| ) | |
| return fig | |
| def get_weekly_summary(self) -> str: | |
| """Generate weekly health summary""" | |
| if len(self.records) < 7: | |
| return "📊 Complete 7 days of check-ins to see your weekly summary!" | |
| recent_records = self.records[-7:] | |
| avg_score = sum(r.daily_score for r in recent_records) / len(recent_records) | |
| # Find trends | |
| scores = [r.daily_score for r in recent_records] | |
| trend = "📈 Improving" if scores[-1] > scores[0] else "📉 Declining" if scores[-1] < scores[0] else "➡️ Stable" | |
| best_day = max(recent_records, key=lambda x: x.daily_score) | |
| summary = f""" | |
| # 📅 Weekly Health Summary | |
| ## 🎯 Average Score: {avg_score:.1f}/100 | |
| ## 📊 Trend: {trend} | |
| ## 🌟 Best Day: {best_day.date} (Score: {best_day.daily_score:.1f}) | |
| ### Key Insights: | |
| - Best performing area: {"Sleep" if sum(r.morning_sleep_quality for r in recent_records) > 42 else "Physical Activity" if sum(r.afternoon_physical_activity for r in recent_records) > 210 else "Nutrition"} | |
| - Focus area: {"Sleep routine" if sum(r.morning_sleep_quality for r in recent_records) < 35 else "Exercise" if sum(r.afternoon_physical_activity for r in recent_records) < 140 else "Stress management"} | |
| *Keep building those healthy habits! 💪* | |
| """ | |
| return summary | |
| # Initialize AI Doctor | |
| ai_doctor = AIDoctor() | |
| # Create Gradio Interface | |
| with gr.Blocks(title="🏥 AI Doctor - Daily Health Checkup", theme=gr.themes.Soft()) as app: | |
| gr.Markdown(""" | |
| # 🏥 AI Doctor - Your Personal Health Assistant | |
| Complete 3 daily check-ins to track your health and get **AI-powered recommendations from Google Gemini**! 🤖✨ | |
| **📱 How it works:** | |
| 1. **Morning Check-in** - Rate your mood, energy, and sleep | |
| 2. **Afternoon Check-in** - Log water, activity, and stress | |
| 3. **Evening Check-in** - Rate meals, screen time, and gratitude | |
| Get your daily health score and personalized AI recommendations! | |
| > 🔑 **Setup**: Add your `GEMINI_API_KEY` in Hugging Face Secrets for enhanced AI recommendations! | |
| """) | |
| # API Key status indicator | |
| if ai_doctor.gemini_available: | |
| gr.Markdown("✅ **Gemini AI Active** - Enhanced recommendations enabled!") | |
| else: | |
| gr.Markdown("⚠️ **Gemini AI Inactive** - Add GEMINI_API_KEY for enhanced recommendations (using fallback mode)") | |
| with gr.Tabs(): | |
| # Morning Check-in Tab | |
| with gr.TabItem("🌅 Morning Check-in"): | |
| gr.Markdown("### Start your day with a quick health check!") | |
| with gr.Row(): | |
| mood_slider = gr.Slider(1, 10, value=7, label="😊 How's your mood? (1=Terrible, 10=Amazing)") | |
| energy_slider = gr.Slider(1, 10, value=7, label="⚡ Energy level? (1=Exhausted, 10=Energetic)") | |
| with gr.Row(): | |
| sleep_slider = gr.Slider(1, 10, value=7, label="💤 Sleep quality? (1=Terrible, 10=Perfect)") | |
| water_goal = gr.Slider(4, 12, value=8, label="💧 Water goal today? (glasses)") | |
| morning_btn = gr.Button("Complete Morning Check-in ✅", variant="primary") | |
| morning_output = gr.Textbox(label="Morning Status", lines=6) | |
| morning_btn.click( | |
| ai_doctor.morning_checkin, | |
| inputs=[mood_slider, energy_slider, sleep_slider, water_goal], | |
| outputs=morning_output | |
| ) | |
| # Afternoon Check-in Tab | |
| with gr.TabItem("🌞 Afternoon Check-in"): | |
| gr.Markdown("### Midday health update!") | |
| with gr.Row(): | |
| water_consumed = gr.Slider(0, 15, value=4, label="💧 Water consumed so far? (glasses)") | |
| activity_minutes = gr.Slider(0, 180, value=30, label="🏃 Physical activity? (minutes)") | |
| stress_slider = gr.Slider(1, 10, value=5, label="😰 Stress level? (1=Zen, 10=Overwhelmed)") | |
| afternoon_btn = gr.Button("Complete Afternoon Check-in ✅", variant="primary") | |
| afternoon_output = gr.Textbox(label="Afternoon Status", lines=6) | |
| afternoon_btn.click( | |
| ai_doctor.afternoon_checkin, | |
| inputs=[water_consumed, activity_minutes, stress_slider], | |
| outputs=afternoon_output | |
| ) | |
| # Evening Check-in Tab | |
| with gr.TabItem("🌙 Evening Check-in"): | |
| gr.Markdown("### End your day and get your health score!") | |
| with gr.Row(): | |
| meal_quality = gr.Slider(1, 10, value=7, label="🥗 Meal quality today? (1=Junk, 10=Nutritious)") | |
| screen_time = gr.Slider(0, 12, value=4, label="📱 Screen time? (hours)") | |
| gratitude_slider = gr.Slider(1, 10, value=7, label="🙏 Gratitude practice? (1=None, 10=Very mindful)") | |
| evening_btn = gr.Button("Complete Evening Check-in & Get Score! 🎯", variant="primary") | |
| with gr.Row(): | |
| evening_status = gr.Textbox(label="Evening Status") | |
| daily_report = gr.Markdown(label="📋 Daily Health Report") | |
| progress_chart = gr.Plot(label="📈 Progress Chart") | |
| evening_btn.click( | |
| ai_doctor.evening_checkin, | |
| inputs=[meal_quality, screen_time, gratitude_slider], | |
| outputs=[evening_status, daily_report, progress_chart] | |
| ) | |
| # Progress Tab | |
| with gr.TabItem("📊 Weekly Summary"): | |
| gr.Markdown("### Your health journey overview") | |
| summary_btn = gr.Button("Generate Weekly Summary 📅", variant="secondary") | |
| weekly_summary = gr.Markdown() | |
| summary_btn.click( | |
| ai_doctor.get_weekly_summary, | |
| outputs=weekly_summary | |
| ) | |
| gr.Markdown(""" | |
| --- | |
| ### 💡 Health Tips: | |
| - **Consistency** is more important than perfection | |
| - Aim for **8 glasses** of water daily | |
| - Get **7-9 hours** of quality sleep | |
| - **30+ minutes** of physical activity | |
| - Practice **gratitude** for mental wellness | |
| *Your AI Doctor is here to help you build lasting healthy habits! 🌟* | |
| """) | |
| if __name__ == "__main__": | |
| app.launch() |