Update app.py

app.py

@@ -1,5 +1,8 @@
 import os
 import json
+import base64
+import tempfile
+import requests
 import firebase_admin
 from firebase_admin import credentials, firestore
 from flask import Flask, request, jsonify
@@ -21,23 +24,28 @@ try:
 except Exception as e:
     print(f"❌ Erro ao inicializar Firebase: {e}")
 
-# ====== MODELO ======
+# ====== MODELO (AUDIO) ======
+# Usamos pipeline de audio-classification com o modelo Whisper fine-tuned fornecido
 try:
-    model_pipeline = pipeline("text-classification", model="pysentimiento/robertuito-emotion-analysis")
-    print("✅ Modelo carregado com sucesso!")
+    audio_pipeline = pipeline(
+        task="audio-classification",
+        model="firdhokk/speech-emotion-recognition-with-openai-whisper-large-v3"
+    )
+    print("✅ Modelo de reconhecimento de emoção por voz carregado com sucesso!")
 except Exception as e:
-    print(f"❌ Erro ao carregar modelo: {e}")
-    model_pipeline = None
+    print(f"❌ Erro ao carregar modelo de áudio: {e}")
+    audio_pipeline = None
 
-# ====== MAPEAMENTO DE EMOÇÕES ======
+# ====== MAPEAMENTO DE EMOÇÕES (ING->PT) ======
 emotion_labels = {
-    "sadness": "tristeza",
-    "joy": "alegria",
-    "anger": "raiva",
-    "fear": "ansiedade",
+    "angry": "raiva",
     "disgust": "insegurança",
-    "surprise": "alegria",
-    "others": "neutro"
+    "fearful": "ansiedade",
+    "happy": "alegria",
+    "neutral": "neutro",
+    "sad": "tristeza",
+    "surprised": "surpreso",
+    # fallback caso o label seja diferente
 }
 
 # ====== SUGESTÕES ======
@@ -82,7 +90,7 @@ def fallback_emotion(text):
 
 # ====== AJUSTE HÍBRIDO ======
 def hybrid_emotion(text, result):
-    text_lower = text.lower()
+    text_lower = (text or "").lower()
     detected = result.get("emotion", "neutro")
     max_matches = 0
 
@@ -108,47 +116,128 @@ def hybrid_emotion(text, result):
         "debug": result.get("debug", "Híbrido aplicado")
     }
 
+# ====== HELPERS PARA ÁUDIO ======
+def save_bytes_to_tempfile(bbytes, suffix=".wav"):
+    fd, path = tempfile.mkstemp(suffix=suffix)
+    os.close(fd)
+    with open(path, "wb") as f:
+        f.write(bbytes)
+    return path
+
+def fetch_url_to_tempfile(url):
+    r = requests.get(url, timeout=15)
+    r.raise_for_status()
+    content_type = r.headers.get("content-type", "")
+    suffix = ".wav"
+    if "mpeg" in content_type or "mp3" in content_type:
+        suffix = ".mp3"
+    return save_bytes_to_tempfile(r.content, suffix=suffix)
+
 # ====== ROTA DE ANÁLISE ======
 @app.route("/analyze", methods=["POST"])
 def analyze():
     try:
-        data = request.get_json()
-        if not data or "text" not in data:
-            return jsonify({"error": "Campo 'text' é obrigatório."}), 400
-
-        text = data["text"]
-
-        if not model_pipeline:
-            return jsonify(fallback_emotion(text))
+        # suportar multipart/form-data com file
+        audio_path = None
+        audio_bytes = None
+        data = None
+
+        # prioridade: arquivos enviados via multipart/form-data
+        if "file" in request.files:
+            f = request.files["file"]
+            audio_bytes = f.read()
+
+        else:
+            # tentar JSON
+            try:
+                data = request.get_json(silent=True)
+            except Exception:
+                data = None
+
+            if data:
+                # base64
+                if "audio_base64" in data:
+                    audio_bytes = base64.b64decode(data["audio_base64"])
+                # url
+                elif "audio_url" in data:
+                    audio_path = fetch_url_to_tempfile(data["audio_url"])
+                # se vier apenas 'text', usar fallback textual
+                elif "text" in data and (not audio_bytes and not audio_path):
+                    text = data["text"]
+                    return jsonify(fallback_emotion(text))
+
+        # se temos bytes, salva como tempfile
+        if audio_bytes:
+            audio_path = save_bytes_to_tempfile(audio_bytes, suffix=".wav")
+
+        # se não há áudio, retornar erro ou fallback
+        if not audio_path:
+            # se data com text já foi tratado acima; aqui devolvemos erro pedindo áudio/text
+            return jsonify({"error": "Nenhum áudio foi enviado. Envie 'file' (multipart/form-data), ou 'audio_base64'/'audio_url', ou 'text' para fallback."}), 400
+
+        # ====== Chamar pipeline de áudio ======
+        if not audio_pipeline:
+            # pipeline indisponível -> tentar extrair texto (se disponível) ou fallback
+            # se houver 'text' em JSON, use fallback_emotion
+            if data and "text" in data:
+                return jsonify(fallback_emotion(data["text"]))
+            return jsonify({"error": "Modelo de áudio indisponível no momento."}), 500
+
+        # A pipeline aceita caminho para arquivo
+        raw_result = audio_pipeline(audio_path, top_k=10)  # lista de dicts: [{'label':..., 'score':...}, ...]
+        # Exemplo: raw_result = [{'label': 'Happy', 'score': 0.9}, ...]
+        # Normalizar labels para minúsculas
+        scores = {}
+        for item in raw_result:
+            label = item.get("label", "").lower()
+            # alguns modelos usam 'fear' vs 'fearful' etc. padronizar
+            if label == "fear":
+                label = "fearful"
+            scores[label] = float(item.get("score", 0.0))
+
+        if not scores:
+            return jsonify({"error": "Nenhum rótulo retornado pelo modelo."}), 500
 
-        result = model_pipeline(text, return_all_scores=True)
-        if not result or len(result) == 0:
-            return jsonify(fallback_emotion(text))
-
-        scores = {r["label"]: r["score"] for r in result[0]}
         top_label = max(scores, key=scores.get)
         confidence = round(scores[top_label], 2)
         emotion_pt = emotion_labels.get(top_label, "desconhecido")
 
-        # Ajuste especial para "tristeza" muito forte
+        # Ajuste especial: se for tristeza muito forte -> 'depressão'
         if emotion_pt == "tristeza" and confidence >= 0.9:
             emotion_pt = "depressão"
 
+        # montar probabilidades mapeadas para pt (mantendo somente rótulos conhecidos)
+        probabilities_pt = { emotion_labels.get(k, k): round(v, 3) for k, v in scores.items() }
+
         base_result = {
             "status": "ok",
             "emotion": emotion_pt,
             "emode": [emotion_pt],
             "confidence": confidence,
-            "probabilities": {emotion_labels.get(k, k): round(v,3) for k,v in scores.items()},
-            "suggestion": gerar_sugestao(emotion_pt)
+            "probabilities": probabilities_pt,
+            "suggestion": gerar_sugestao(emotion_pt),
+            "debug": "Modelo de áudio utilizado"
         }
 
-        # Aplica lógica híbrida com fallback de palavras-chave
-        final_result = hybrid_emotion(text, base_result)
+        # Ler (tentar) a transcrição de texto se o modelo retornar (muitos pipelines de audio-classification não transcrevem)
+        # Como fallback híbrido, se o usuário mandou também 'text' no JSON, usaremos isso para o híbrido.
+        text_for_hybrid = None
+        if data and "text" in data:
+            text_for_hybrid = data["text"]
+
+        final_result = hybrid_emotion(text_for_hybrid, base_result) if text_for_hybrid else base_result
+
         return jsonify(final_result)
 
     except Exception as e:
         return jsonify({"error": str(e)}), 500
+    finally:
+        # limpar tempfiles (se existirem)
+        try:
+            if 'audio_path' in locals() and audio_path and os.path.exists(audio_path):
+                os.remove(audio_path)
+        except Exception:
+            pass
 
 if __name__ == "__main__":
-    app.run(host="0.0.0.0", port=7860)
+    app.run(host="0.0.0.0", port=int(os.getenv("PORT", 7860)))