Upload 2 files

app.py

@@ -1,251 +1,121 @@
 import os
 import datetime
 import logging
+import io
 import base64
 import uuid
+
 import cv2
 import pandas as pd
 import numpy as np
 import librosa
 import torch
 from transformers import Wav2Vec2ForSequenceClassification, Wav2Vec2FeatureExtractor
+from deepface import DeepFace
+
 from flask import Flask, request, jsonify, render_template
-from pydub import AudioSegment
 
-# Initialize Flask app
+# --- App & Logger Setup ---
 app = Flask(__name__)
-
-# Configure logging
 logging.basicConfig(
     level=logging.INFO,
     format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
 )
 
-# File paths
+# --- Constants & Directory Setup ---
 LOG_FILE = "wellbeing_logs.csv"
 CAPTURED_IMAGE_DIR = "captured_images"
 TEMP_AUDIO_DIR = "temp_audio"
 
-# Create directories
 os.makedirs(CAPTURED_IMAGE_DIR, exist_ok=True)
 os.makedirs(TEMP_AUDIO_DIR, exist_ok=True)
 
-# Configure FFmpeg for PythonAnywhere
-AudioSegment.converter = "/usr/bin/ffmpeg"
-AudioSegment.ffprobe = "/usr/bin/ffprobe"
-
-# Global model variables
+# --- Caching the Model ---
 voice_model = None
 voice_feature_extractor = None
 
 def load_voice_emotion_model():
-    """Load voice emotion recognition model"""
     global voice_model, voice_feature_extractor
     if voice_model is None:
-        logging.info("Loading voice emotion model...")
+        logging.info("Loading voice emotion model for the first time...")
         model_name = "superb/wav2vec2-base-superb-er"
         voice_model = Wav2Vec2ForSequenceClassification.from_pretrained(model_name)
         voice_feature_extractor = Wav2Vec2FeatureExtractor.from_pretrained(model_name)
-        logging.info("Voice emotion model loaded successfully.")
+        logging.info("Voice emotion model loaded.")
     return voice_model, voice_feature_extractor
 
-def expand_voice_emotion_label(short_label):
-    """Expand abbreviated emotion labels"""
-    voice_label_mapping = {
-        'sad': 'Sadness',
-        'ang': 'Anger',
-        'hap': 'Happiness',
-        'neu': 'Neutral',
-        'fea': 'Fear',
-        'dis': 'Disgust',
-        'sur': 'Surprise',
-        'calm': 'Calm',
-        'anxious': 'Anxious',
-        'stressed': 'Stressed'
-    }
-    return voice_label_mapping.get(short_label.lower(), short_label.title())
-
+# --- Analysis Functions ---
 def analyze_voice_emotion(audio_file_path):
-    """Analyze emotion from audio file"""
     try:
         model, feature_extractor = load_voice_emotion_model()
         y, sr = librosa.load(audio_file_path, sr=16000, mono=True)
-        
         if y.shape[0] == 0:
             logging.warning(f"Audio file {audio_file_path} was empty.")
             return "Error: Invalid or empty audio"
-            
         inputs = feature_extractor(y, sampling_rate=sr, return_tensors="pt", padding=True)
-        
         with torch.no_grad():
             logits = model(**inputs).logits
-            predicted_id = torch.argmax(logits, dim=-1).item()
-            
-        raw_emotion = model.config.id2label[predicted_id]
-        return expand_voice_emotion_label(raw_emotion)
-        
+        predicted_id = torch.argmax(logits, dim=-1).item()
+        return model.config.id2label[predicted_id]
     except Exception as e:
-        logging.exception(f"Voice emotion analysis failed: {e}")
+        logging.exception(f"Voice emotion analysis failed for file {audio_file_path}: {e}")
         return "Error: Voice analysis failed"
 
-def analyze_emotion_from_data(image_bytes, detector_backend="opencv"):
-    """Analyze emotion from image data using OpenCV (lightweight)"""
+def analyze_emotion_from_data(image_bytes, detector_backend="retinaface"):
     try:
-        if not image_bytes or len(image_bytes) == 0:
-            logging.error("Empty image data received")
-            return "Error: Empty image data"
-        
         nparr = np.frombuffer(image_bytes, np.uint8)
         img_np = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
-        
         if img_np is None:
-            logging.error("Could not decode image")
             return "Error: Could not decode image"
         
-        # Use DeepFace for emotion detection
-        from deepface import DeepFace
-        
-        result = DeepFace.analyze(
-            img_path=img_np,
-            actions=['emotion'],
-            detector_backend=detector_backend,
-            enforce_detection=False
-        )
-        
+        # Use a fallback detector if the selected one fails
+        try:
+            result = DeepFace.analyze(
+                img_path=img_np, actions=['emotion'],
+                detector_backend=detector_backend, enforce_detection=False
+            )
+        except Exception as detector_error:
+            logging.warning(f"Detector '{detector_backend}' failed: {detector_error}. Falling back to 'opencv'.")
+            result = DeepFace.analyze(
+                img_path=img_np, actions=['emotion'],
+                detector_backend='opencv', enforce_detection=False
+            )
+
         if isinstance(result, list) and len(result) > 0:
             return result[0].get("dominant_emotion", "No face detected")
-        return "No face detected"
-        
+        else:
+            return "No face detected"
     except Exception as e:
-        logging.exception(f"Face emotion analysis failed: {e}")
+        logging.exception(f"Face emotion analysis failed with backend {detector_backend}: {e}")
         return "Error: Face analysis failed"
 
 def assess_stress_enhanced(face_emotion, sleep_hours, activity_level, voice_emotion):
-    """Calculate stress score and generate feedback"""
     activity_map = {"Very Low": 3, "Low": 2, "Moderate": 1, "High": 0}
-    emotion_map = {
-        "angry": 2, "disgust": 2, "fear": 2, "sad": 2,
-        "neutral": 1, "surprise": 1, "happy": 0
-    }
-    
+    emotion_map = { "angry": 2, "disgust": 2, "fear": 2, "sad": 2, "neutral": 1, "surprise": 1, "happy": 0 }
     face_emotion_score = emotion_map.get(str(face_emotion).lower(), 1)
     voice_emotion_score = emotion_map.get(str(voice_emotion).lower(), 1)
     emotion_score = round((face_emotion_score + voice_emotion_score) / 2) if voice_emotion != "N/A" else face_emotion_score
     activity_score = activity_map.get(str(activity_level), 1)
-    
     try:
         sleep_hours = float(sleep_hours)
         sleep_score = 0 if sleep_hours >= 7 else (1 if sleep_hours >= 5 else 2)
     except (ValueError, TypeError):
         sleep_score, sleep_hours = 2, 0
-        
     stress_score = emotion_score + activity_score + sleep_score
-    
-    feedback = f"""
-    <div class="assessment-container">
-        <div class="assessment-header">
-            <h3>Your Wellbeing Assessment</h3>
-            <div class="stress-level-indicator level-{min(stress_score, 6)}">
-                Stress Level: <strong>{stress_score}/8</strong>
-            </div>
-        </div>
-        <div class="assessment-breakdown">
-            <div class="factor-row">
-                <span class="factor-label">Facial Expression:</span>
-                <span class="factor-value">{face_emotion}</span>
-                <span class="factor-score">({face_emotion_score} pts)</span>
-            </div>
-            <div class="factor-row">
-                <span class="factor-label">Voice Tone:</span>
-                <span class="factor-value">{voice_emotion}</span>
-                <span class="factor-score">({voice_emotion_score} pts)</span>
-            </div>
-            <div class="factor-row">
-                <span class="factor-label">Sleep Duration:</span>
-                <span class="factor-value">{sleep_hours} hours</span>
-                <span class="factor-score">({sleep_score} pts)</span>
-            </div>
-            <div class="factor-row">
-                <span class="factor-label">Activity Level:</span>
-                <span class="factor-value">{activity_level}</span>
-                <span class="factor-score">({activity_score} pts)</span>
-            </div>
-        </div>
-    """
-    
+    feedback = f"**Your potential stress score is {stress_score} (lower is better).**\n\n**Breakdown:**\n"
+    feedback += f"- Face Emotion: {face_emotion} (score: {face_emotion_score})\n"
+    feedback += f"- Voice Emotion: {voice_emotion} (score: {voice_emotion_score})\n"
+    feedback += f"- Sleep: {sleep_hours} hours (score: {sleep_score})\n"
+    feedback += f"- Activity: {activity_level} (score: {activity_score})\n"
     if stress_score <= 2:
-        feedback += '<div class="assessment-message positive">🌟 Great! You\'re in a good mental space.</div>'
+        feedback += "\nGreat job! You seem to be in a good space."
     elif stress_score <= 4:
-        feedback += '<div class="assessment-message neutral">😌 You\'re managing well. Consider mindfulness practices.</div>'
+        feedback += "\nYou're doing okay, but remember to be mindful of your rest and mood."
     else:
-        feedback += '<div class="assessment-message concerning">🤗 Consider self-care activities to reduce stress.</div>'
-    
-    feedback += "</div>"
+        feedback += "\nConsider taking some time for self-care. Improving sleep or gentle activity might help."
     return feedback, stress_score
 
-def generate_ai_insights(face_emotion, voice_emotion, sleep_hours, activity_level, stress_score):
-    """Generate personalized AI insights"""
-    insights = []
-    
-    if 'sad' in str(face_emotion).lower() or 'angry' in str(face_emotion).lower():
-        insights.append("Try mood-lifting activities like listening to music or spending time in nature")
-    
-    if str(voice_emotion).lower() in ['sadness', 'anger', 'stressed']:
-        insights.append("Practice deep breathing to release vocal tension")
-    
-    if float(sleep_hours) < 6:
-        insights.append("Prioritize sleep hygiene for better emotional regulation")
-    
-    if str(activity_level).lower() == 'very low':
-        insights.append("Gentle movement like stretching can help reduce stress")
-    
-    if stress_score >= 5:
-        insights.append("Connect with supportive people in your life")
-    
-    if not insights:
-        insights.append("Keep up your healthy habits! You're doing great.")
-    
-    return insights[:3]
-
-def get_crisis_resources():
-    """Return crisis support resources"""
-    return [
-        {"name": "Crisis Text Line", "number": "Text HOME to 741741", "description": "24/7 crisis support via text"},
-        {"name": "National Suicide Prevention Lifeline", "number": "988", "description": "Free and confidential support 24/7"},
-        {"name": "Veterans Crisis Line", "number": "1-800-273-8255", "description": "Support for veterans"},
-        {"name": "Emergency Services", "number": "911", "description": "Immediate emergency assistance"}
-    ]
-
-def get_coping_techniques():
-    """Return coping techniques"""
-    return [
-        {
-            "name": "Deep Breathing",
-            "description": "4-7-8 breathing pattern to reduce anxiety",
-            "instructions": "Breathe in for 4 counts, hold for 7, exhale for 8. Repeat 4 times.",
-            "duration": "2-3 minutes"
-        },
-        {
-            "name": "Grounding Exercise",
-            "description": "5-4-3-2-1 sensory technique",
-            "instructions": "Name 5 things you see, 4 you can touch, 3 you hear, 2 you smell, 1 you taste.",
-            "duration": "3-5 minutes"
-        },
-        {
-            "name": "Progressive Relaxation",
-            "description": "Tense and release muscle groups",
-            "instructions": "Start with your toes, tense for 5 seconds, then relax. Move up through your body.",
-            "duration": "10-15 minutes"
-        },
-        {
-            "name": "Mindful Meditation",
-            "description": "Focus on present moment awareness",
-            "instructions": "Sit quietly, focus on your breath, notice thoughts without judgment.",
-            "duration": "5-20 minutes"
-        }
-    ]
-
-# Flask Routes
+# --- Flask Routes ---
 @app.route('/')
 def index():
     return render_template('index.html')
@@ -253,17 +123,15 @@ def index():
 @app.route('/analyze_face', methods=['POST'])
 def analyze_face_endpoint():
     data = request.json
-    detector = data.get('detector', 'opencv')
+    detector = data.get('detector', 'retinaface')
     image_data = base64.b64decode(data['image'].split(',')[1])
     emotion = analyze_emotion_from_data(image_data, detector_backend=detector)
-    
     image_path = "N/A"
-    if not emotion.startswith("Error:") and emotion != "No face detected":
+    if not emotion.startswith("Error:") and not emotion == "No face detected":
         filename = f"face_{uuid.uuid4()}.jpg"
         image_path = os.path.join(CAPTURED_IMAGE_DIR, filename)
         with open(image_path, "wb") as f:
             f.write(image_data)
-    
     return jsonify({'emotion': emotion, 'image_path': image_path})
 
 @app.route('/analyze_voice', methods=['POST'])
@@ -271,27 +139,15 @@ def analyze_voice_endpoint():
     audio_file = request.files.get('audio')
     if not audio_file:
         return jsonify({'error': 'No audio file provided'}), 400
-    
-    webm_filename = f"{uuid.uuid4()}.webm"
-    wav_filename = webm_filename.replace(".webm", ".wav")
-    
-    webm_filepath = os.path.join(TEMP_AUDIO_DIR, webm_filename)
-    wav_filepath = os.path.join(TEMP_AUDIO_DIR, wav_filename)
-    
+    temp_filename = f"{uuid.uuid4()}.webm"
+    temp_filepath = os.path.join(TEMP_AUDIO_DIR, temp_filename)
     try:
-        audio_file.save(webm_filepath)
-        sound = AudioSegment.from_file(webm_filepath, format="webm")
-        sound.export(wav_filepath, format="wav")
-        emotion = analyze_voice_emotion(wav_filepath)
-        return jsonify({'voice_emotion': emotion})
-    except Exception as e:
-        logging.exception(f"Error in voice pipeline: {e}")
-        return jsonify({'error': str(e)}), 500
+        audio_file.save(temp_filepath)
+        emotion = analyze_voice_emotion(temp_filepath)
     finally:
-        if os.path.exists(webm_filepath):
-            os.remove(webm_filepath)
-        if os.path.exists(wav_filepath):
-            os.remove(wav_filepath)
+        if os.path.exists(temp_filepath):
+            os.remove(temp_filepath)
+    return jsonify({'voice_emotion': emotion})
 
 @app.route('/log_checkin', methods=['POST'])
 def log_checkin_endpoint():
@@ -299,7 +155,7 @@ def log_checkin_endpoint():
     feedback, stress_score = assess_stress_enhanced(
         data['emotion'], data['sleep_hours'], data['activity_level'], data['voice_emotion']
     )
-    
+    # *** FIX: Format timestamp as a consistent string BEFORE saving ***
     new_log_entry = {
         "timestamp": datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
         "face_emotion": data['emotion'],
@@ -307,26 +163,14 @@ def log_checkin_endpoint():
         "sleep_hours": data['sleep_hours'],
         "activity_level": data['activity_level'],
         "stress_score": stress_score,
-        "detector_backend": data.get('detector', 'opencv'),
-        "image_path": data.get('image_path', 'N/A'),
-        "mood": data.get('mood', 'Not specified')
+        "detector_backend": data.get('detector', 'retinaface'),
+        "image_path": data.get('image_path', 'N/A')
     }
-    
-    ai_insights = generate_ai_insights(
-        data['emotion'], data.get('voice_emotion', 'N/A'),
-        data['sleep_hours'], data['activity_level'], stress_score
-    )
-    
     try:
         header = not os.path.exists(LOG_FILE)
         df_new = pd.DataFrame([new_log_entry])
         df_new.to_csv(LOG_FILE, mode='a', header=header, index=False)
-        return jsonify({
-            'feedback': feedback,
-            'stress_score': stress_score,
-            'ai_insights': ai_insights,
-            'status': 'success'
-        })
+        return jsonify({'feedback': feedback, 'stress_score': stress_score, 'status': 'success'})
     except Exception as e:
         logging.exception(f"Could not save log: {e}")
         return jsonify({'error': f'Could not save log: {e}'}), 500
@@ -337,6 +181,7 @@ def get_logs_endpoint():
         return jsonify({'data': [], 'columns': []})
     try:
         df = pd.read_csv(LOG_FILE)
+        # *** FIX: No need to parse/reformat timestamps. They are already correct strings. ***
         return jsonify({
             'data': df.to_dict(orient='records'),
             'columns': df.columns.tolist()
@@ -356,15 +201,11 @@ def clear_logs_endpoint():
             if os.path.exists(directory):
                 for f in os.listdir(directory):
                     os.remove(os.path.join(directory, f))
-        return jsonify({'status': 'success', 'message': 'All logs cleared.'})
+        return jsonify({'status': 'success', 'message': 'All logs and images cleared.'})
     except Exception as e:
         logging.exception(f"Error clearing logs: {e}")
         return jsonify({'status': 'error', 'message': str(e)}), 500
 
-@app.route('/get_crisis_resources', methods=['GET'])
-def get_crisis_resources_endpoint():
-    return jsonify(get_crisis_resources())
-
-@app.route('/get_coping_techniques', methods=['GET'])
-def get_coping_techniques_endpoint():
-    return jsonify(get_coping_techniques())
+if __name__ == '__main__':
+    load_voice_emotion_model()
+    app.run(debug=True, host='0.0.0.0')

requirements.txt

@@ -1,22 +1,19 @@
-Flask==3.0.0
-gunicorn==21.2.0
-pandas==2.1.4
-numpy==1.26.2
-opencv-python-headless==4.8.1.78
-librosa==0.10.1
-soundfile==0.12.1
-torch==2.1.1
-torchvision==0.16.1
-torchaudio==2.1.1
-transformers==4.36.2
-pydub==0.25.1
-Pillow==10.1.0
-audioread==3.0.1
+# requirements.txt
 
-# --- CRITICAL: TensorFlow and Keras Compatibility Fix ---
-tensorflow==2.15.1
-tf-keras==2.15.1  # This is the key fix!
-deepface==0.0.92
-mtcnn==0.1.1
-retina-face==0.0.13
-# -------------------------------------------------------------
+Flask
+pandas
+numpy
+opencv-python
+deepface
+librosa
+torch
+transformers
+soundfile
+gunicorn
+tf-keras
+accelerate
+safetensors
+mediapipe
+sentencepiece
+scipy
+requests