Update app.py

app.py

@@ -12,8 +12,183 @@ from datasets import load_dataset
 from gtts import gTTS
 import os
 import speech_recognition as sr
+import soundfile as sf  # Import soundfile
 
-# [Previous code blocks remain unchanged up to diabetes_dashboard function]
+# Define constants and data structures
+INSULIN_TYPES = {
+    "Rapid-Acting": 1.0,
+    "Short-Acting": 0.8,
+    "Intermediate-Acting": 0.6,
+    "Long-Acting": 0.4
+}
+
+DEFAULT_BASAL_RATES = {
+    "00:00": 0.8,
+    "03:00": 0.7,
+    "06:00": 0.9,
+    "09:00": 1.0,
+    "12:00": 0.9,
+    "15:00": 0.8,
+    "18:00": 0.9,
+    "21:00": 0.8
+}
+
+# Load food data from CSV
+def load_food_data():
+    try:
+        food_data = pd.read_csv("food_data.csv")
+        return food_data
+    except FileNotFoundError:
+        print("Error: food_data.csv not found.")
+        return pd.DataFrame()
+
+# Save audio to a temporary file
+def save_audio(filepath, audio_data):
+    sf.write(filepath, audio_data[0], audio_data[1])
+
+# Recognize food name from audio
+def recognize_food_from_voice(food_audio):
+    try:
+        audio_path = "audio_temp.wav"
+        save_audio(audio_path, food_audio)
+
+        r = sr.Recognizer()
+        with sr.AudioFile(audio_path) as source:
+            audio = r.record(source)
+
+        food_name = r.recognize_google(audio)
+        os.remove(audio_path)  # Clean up the temp file
+        return food_name
+    except Exception as e:
+        print(f"Error recognizing food from voice: {e}")
+        return None
+
+# Classify food from image (replace with your image classification model)
+def classify_food(image):
+    # Load pre-trained image classification model
+    image_processor = AutoImageProcessor.from_pretrained("google/vit-base-patch16-224")
+    model = AutoModelForImageClassification.from_pretrained("google/vit-base-patch16-224")
+
+    try:
+        inputs = image_processor(images=image, return_tensors="pt")
+        outputs = model(**inputs)
+        logits = outputs.logits
+        predicted_class_idx = logits.argmax(-1).item()
+        predicted_label = model.config.id2label[predicted_class_idx]
+        return predicted_label
+    except Exception as e:
+        print(f"Error classifying image: {e}")
+        return "Unknown Food"
+
+# Get nutrition information for a given food (fuzzy matching)
+def get_food_nutrition(food_name, food_data, portion_size):
+    if food_data.empty:
+        return None
+
+    food_names = food_data["Food"].tolist()
+    closest_match = get_close_matches(food_name, food_names, n=1, cutoff=0.6)
+
+    if closest_match:
+        matched_food = closest_match[0]
+        food_info = food_data[food_data["Food"] == matched_food].iloc[0]
+
+        carbs_per_portion = food_info["Carbs"]
+        fat_per_portion = food_info["Fat"]
+        protein_per_portion = food_info["Protein"]
+        fiber_per_portion = food_info["Fiber"]
+
+        adjusted_carbs = max(0, carbs_per_portion - (fiber_per_portion / 2)) * portion_size
+
+        return {
+            "matched_food": matched_food,
+            "portion_size": portion_size,
+            "carbs_per_portion": carbs_per_portion * portion_size,
+            "fat_per_portion": fat_per_portion * portion_size,
+            "protein_per_portion": protein_per_portion * portion_size,
+            "fiber_per_portion": fiber_per_portion * portion_size,
+            "adjusted_carbs": adjusted_carbs
+        }
+    else:
+        return None
+
+# Calculate Insulin Needs
+def calculate_insulin_needs(adjusted_carbs, initial_glucose, target_glucose, tdd, weight, insulin_type, override_correction_dose=None):
+    try:
+        isf = 1800 / tdd  # Insulin Sensitivity Factor
+        carb_ratio = 500 / tdd  # Carb Ratio
+
+        # Correction Dose Calculation
+        if override_correction_dose is not None:
+            correction_dose = override_correction_dose
+        else:
+            correction_dose = (initial_glucose - target_glucose) / isf
+
+        # Carb Dose Calculation
+        carb_dose = adjusted_carbs / carb_ratio
+
+        # Total Bolus Dose
+        total_bolus = correction_dose + carb_dose
+
+        # ISF Modifier based on Insulin Type
+        isf_modifier = INSULIN_TYPES.get(insulin_type, 1.0) # Default to 1.0 if insulin type not found
+        total_bolus *= isf_modifier
+
+        return {
+            "isf": isf,
+            "carb_ratio": carb_ratio,
+            "correction_dose": correction_dose,
+            "carb_dose": carb_dose,
+            "total_bolus": total_bolus,
+            "insulin_type": insulin_type,
+            "target_glucose": target_glucose,
+            "initial_glucose": initial_glucose
+        }
+
+    except Exception as e:
+        return {"error": f"Error calculating insulin: {e}"}
+
+# Get Basal Rate
+def get_basal_rate(time_hours, basal_rates):
+    time_str = "{:02d}:00".format(time_hours % 24)  # Format as HH:00
+    for t in sorted(basal_rates.keys()):
+        if time_str >= t:
+            current_basal_rate = basal_rates[t]
+        else:
+            break
+    return current_basal_rate
+
+# Active Insulin Calculation (Simple Exponential Decay Model)
+def calculate_active_insulin(insulin_history, time):
+    active_insulin = 0
+    for bolus_time, bolus_amount, insulin_type, duration in insulin_history:
+        time_elapsed = time - bolus_time
+        if time_elapsed < duration:
+            # Using exponential decay for simplicity
+            active_insulin += bolus_amount * np.exp(-time_elapsed / (duration / np.log(2)))
+    return active_insulin
+
+def create_detailed_report(nutrition_info, insulin_info, current_basal_rate):
+    # Format the report string
+    glucose_meal_details = f"### Glucose & Meal Details\n\n" \
+                           f"- **Detected Food:** {nutrition_info['matched_food']}\n" \
+                           f"- **Portion Size:** {nutrition_info['portion_size']}\n" \
+                           f"- **Carbohydrates:** {nutrition_info['carbs_per_portion']} g\n" \
+                           f"- **Adjusted Carbs:** {nutrition_info['adjusted_carbs']} g\n"
+
+    insulin_details = f"### Insulin Details\n\n" \
+                      f"- **Blood Glucose Target:** {insulin_info['target_glucose']} mg/dL\n" \
+                      f"- **Current Glucose Level:** {insulin_info['initial_glucose']} mg/dL\n" \
+                      f"- **Insulin Sensitivity Factor (ISF):** {insulin_info['isf']:.2f}\n" \
+                      f"- **Carb Ratio:** {insulin_info['carb_ratio']:.2f} g/U\n" \
+                      f"- **Correction Dose:** {insulin_info['correction_dose']:.2f} U\n" \
+                      f"- **Carb Dose:** {insulin_info['carb_dose']:.2f} U\n" \
+                      f"- **Total Bolus Dose:** {insulin_info['total_bolus']:.2f} U\n" \
+                      f"- **Insulin Type:** {insulin_info['insulin_type']}"
+
+    basal_details = f"### Basal Settings\n\n" \
+                    f"- **Current Basal Rate:** {current_basal_rate} U/hr\n"
+
+    return glucose_meal_details, insulin_details, basal_details
 
 # Main Dashboard with Voice Input
 def diabetes_dashboard(initial_glucose, food_audio, food_image, portion_size,
@@ -84,12 +259,13 @@ def diabetes_dashboard(initial_glucose, food_audio, food_image, portion_size,
     speech_output = f"Food detected: {nutrition_info['matched_food']}. " \
                     f"Total carbs: {nutrition_info['adjusted_carbs']} grams. " \
                     f"Recommended bolus dose: {insulin_info['total_bolus']} units."
+    audio_file = "recommendation.mp3" # relative path
+
     tts = gTTS(text=speech_output, lang='en')
-    audio_file = "recommendation.mp3"
-    tts.save(audio_file)
+    tts.save(audio_file) # save it in the app directory
 
-    return (glucose_meal_details + insulin_details + basal_details, 
-            plt, 
+    return (glucose_meal_details + insulin_details + basal_details,
+            fig,  # Pass the matplotlib figure object
             audio_file,
             glucose_meal_details,
             insulin_details,
@@ -98,7 +274,7 @@ def diabetes_dashboard(initial_glucose, food_audio, food_image, portion_size,
 # Gradio Interface
 with gr.Blocks(title="Diabetes Management Dashboard") as demo:
     gr.Markdown("# Diabetes Management Dashboard")
-    
+
     with gr.Row():
         with gr.Column():
             # Input Components
@@ -116,13 +292,13 @@ with gr.Blocks(title="Diabetes Management Dashboard") as demo:
                 value=json.dumps(DEFAULT_BASAL_RATES),
                 label="Basal Rates (JSON format)"
             )
-            
+
             with gr.Accordion("Lifestyle Factors"):
                 stress = gr.Slider(0, 10, value=3, label="Stress Level")
                 sleep = gr.Slider(0, 12, value=8, label="Sleep Hours")
                 exercise_dur = gr.Slider(0, 240, value=0, label="Exercise Duration (min)")
                 exercise_int = gr.Slider(0, 10, value=0, label="Exercise Intensity")
-            
+
             time_horizon = gr.Slider(1, 24, value=6, step=1, label="Prediction Time (hours)")
             submit_btn = gr.Button("Calculate")