Update app.py

app.py

@@ -0,0 +1,221 @@
+from flask import Flask, request, jsonify
+from flask_cors import CORS
+from deepface import DeepFace
+import base64
+import io
+from PIL import Image
+import numpy as np
+import logging
+import traceback
+import os
+import spotipy
+from spotipy.oauth2 import SpotifyClientCredentials
+
+# Suppress TensorFlow warnings
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
+os.environ['TF_ENABLE_ONEDNN_OPTS'] = '0'
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(_name_)
+
+app = Flask(_name_)
+CORS(app)
+
+# Initialize Spotify
+try:
+    # Set your Spotify credentials here or use environment variables
+    SPOTIFY_CLIENT_ID = os.getenv('SPOTIFY_CLIENT_ID', 'your_client_id_here')
+    SPOTIFY_CLIENT_SECRET = os.getenv('SPOTIFY_CLIENT_SECRET', 'your_client_secret_here')
+    
+    client_credentials_manager = SpotifyClientCredentials(
+        client_id=SPOTIFY_CLIENT_ID,
+        client_secret=SPOTIFY_CLIENT_SECRET
+    )
+    spotify = spotipy.Spotify(client_credentials_manager=client_credentials_manager)
+    logger.info("Spotify API initialized successfully")
+except Exception as e:
+    logger.error(f"Failed to initialize Spotify API: {str(e)}")
+    spotify = None
+
+# Emotion to Spotify search queries
+EMOTION_TO_MOOD = {
+    'happy': ['happy hits', 'feel good', 'party music', 'upbeat pop'],
+    'sad': ['sad songs', 'emotional ballads', 'melancholic', 'rainy day'],
+    'angry': ['workout motivation', 'rock anthems', 'intense metal', 'aggressive'],
+    'neutral': ['chill vibes', 'focus music', 'ambient', 'lo-fi beats'],
+    'surprise': ['party hits', 'dance pop', 'exciting', 'upbeat'],
+    'fear': ['calming music', 'meditation', 'peaceful', 'relaxation'],
+    'disgust': ['energizing', 'workout', 'rock music', 'alternative']
+}
+
+@app.route('/', methods=['GET'])
+def home():
+    return jsonify({
+        "message": "Emotion Detection + Music Recommendation API",
+        "endpoints": {
+            "/emotion": "POST - Detect emotion from image",
+            "/health": "GET - Health check"
+        },
+        "music_provider": "Spotify"
+    })
+
+@app.route('/health', methods=['GET'])
+def health():
+    return jsonify({
+        "status": "healthy",
+        "spotify_available": spotify is not None
+    }), 200
+
+@app.route('/emotion', methods=['POST', 'OPTIONS'])
+def detect_emotion():
+    if request.method == 'OPTIONS':
+        return jsonify({}), 200
+        
+    try:
+        logger.info("Received emotion detection request")
+        
+        data = request.get_json()
+        
+        if not data or 'image' not in data:
+            logger.error("No image data in request")
+            return jsonify({
+                "success": False,
+                "error": "No image data provided"
+            }), 400
+        
+        image_data = data['image']
+        logger.info(f"Received image data, length: {len(image_data)}")
+        
+        if ',' in image_data:
+            image_data = image_data.split(',')[1]
+        
+        try:
+            image_bytes = base64.b64decode(image_data)
+            logger.info(f"Decoded image bytes: {len(image_bytes)} bytes")
+        except Exception as e:
+            logger.error(f"Base64 decode error: {str(e)}")
+            return jsonify({
+                "success": False,
+                "error": "Invalid base64 image data"
+            }), 400
+        
+        try:
+            image = Image.open(io.BytesIO(image_bytes))
+            logger.info(f"Image opened - Format: {image.format}, Size: {image.size}, Mode: {image.mode}")
+        except Exception as e:
+            logger.error(f"PIL image open error: {str(e)}")
+            return jsonify({
+                "success": False,
+                "error": "Invalid image format"
+            }), 400
+        
+        if image.mode != 'RGB':
+            logger.info(f"Converting image from {image.mode} to RGB")
+            image = image.convert('RGB')
+        
+        img_array = np.array(image)
+        logger.info(f"Numpy array shape: {img_array.shape}, dtype: {img_array.dtype}")
+        
+        try:
+            logger.info("Starting DeepFace analysis...")
+            result = DeepFace.analyze(
+                img_array, 
+                actions=['emotion'],
+                enforce_detection=False,
+                silent=True,
+                detector_backend='opencv'
+            )
+            logger.info("DeepFace analysis completed successfully")
+        except Exception as e:
+            logger.error(f"DeepFace analysis error: {str(e)}")
+            logger.error(traceback.format_exc())
+            return jsonify({
+                "success": False,
+                "error": f"Emotion detection failed: {str(e)}"
+            }), 500
+        
+        if isinstance(result, list):
+            result = result[0]
+        
+        dominant_emotion = result['dominant_emotion']
+        emotion_scores = result['emotion']
+        
+        emotion_scores_serializable = {
+            emotion: float(score) for emotion, score in emotion_scores.items()
+        }
+        
+        logger.info(f"Dominant emotion: {dominant_emotion}")
+        
+        music_recommendations = []
+        if spotify:
+            try:
+                music_recommendations = get_music_from_spotify(dominant_emotion)
+                logger.info(f"Found {len(music_recommendations)} music recommendations")
+            except Exception as e:
+                logger.warning(f"Failed to get music recommendations: {str(e)}")
+        
+        return jsonify({
+            "success": True,
+            "dominant_emotion": dominant_emotion,
+            "all_emotions": emotion_scores_serializable,
+            "confidence": float(emotion_scores[dominant_emotion]),
+            "music_recommendations": music_recommendations,
+            "suggested_moods": EMOTION_TO_MOOD.get(dominant_emotion, [])
+        })
+    
+    except Exception as e:
+        logger.error(f"Unexpected error: {str(e)}")
+        logger.error(traceback.format_exc())
+        return jsonify({
+            "success": False,
+            "error": f"Internal server error: {str(e)}"
+        }), 500
+
+def get_music_from_spotify(emotion):
+    """Get music playlists from Spotify based on emotion"""
+    try:
+        mood_keywords = EMOTION_TO_MOOD.get(emotion, ['chill'])
+        recommendations = []
+        
+        for keyword in mood_keywords[:3]:
+            try:
+                results = spotify.search(q=keyword, type='playlist', limit=3)
+                
+                for playlist in results['playlists']['items']:
+                    if playlist:
+                        # Get playlist image
+                        thumbnail = ''
+                        if playlist.get('images') and len(playlist['images']) > 0:
+                            thumbnail = playlist['images'][0]['url']
+                        
+                        recommendations.append({
+                            'title': playlist.get('name', ''),
+                            'playlist_id': playlist.get('id', ''),
+                            'playlist_url': playlist.get('external_urls', {}).get('spotify', ''),
+                            'thumbnail': thumbnail,
+                            'author': playlist.get('owner', {}).get('display_name', 'Spotify'),
+                            'item_count': playlist.get('tracks', {}).get('total', 0),
+                            'mood': keyword,
+                            'provider': 'spotify'
+                        })
+                
+                if len(recommendations) >= 6:
+                    break
+                    
+            except Exception as e:
+                logger.warning(f"Search failed for keyword '{keyword}': {str(e)}")
+                continue
+        
+        return recommendations[:6]
+        
+    except Exception as e:
+        logger.error(f"Error getting music recommendations: {str(e)}")
+        return []
+
+if _name_ == '_main_':
+    logger.info("Starting Emotion Detection + Music Recommendation API on port 7860...")
+    app.run(host='0.0.0.0', port=7860, debug=False)