Update app.py

app.py

@@ -1,96 +1,73 @@
-from fastapi import FastAPI
-from pydantic import BaseModel
-import httpx
 import os
-
-app = FastAPI()
-
-# Garante que a chave existe
-HF_API_KEY = os.getenv("HF_API_KEY", "").strip()
-if not HF_API_KEY:
-    print("⚠️ Aviso: Variável HF_API_KEY não configurada. A API pode não funcionar.")
-
-TRANSLATION_MODEL = "Helsinki-NLP/opus-mt-pt-en"
-EMOTION_MODEL = "j-hartmann/emotion-english-distilroberta-base"
-
-
-class TextInput(BaseModel):
-    text: str
-
-
-EMOTION_SUGGESTIONS = {
-    "joy": "Ótimo! Continue aproveitando esses momentos positivos!",
-    "anger": "Respire fundo e tente se acalmar antes de reagir.",
-    "sadness": "Permita-se sentir, e tente falar ou escrever sobre isso.",
-    "fear": "Tente identificar o que causa medo e enfrente aos poucos.",
-    "surprise": "Que surpresa interessante! Observe como se sente.",
-    "disgust": "Tente refletir sobre o que causou esse sentimento.",
-    "neutral": "Mantenha-se atento aos seus sentimentos e observe-os.",
-    "love": "Aproveite esses sentimentos positivos e compartilhe-os!",
-}
-DEFAULT_SUGGESTION = "Tente respirar fundo e escrever seus sentimentos."
-
-
-async def query_inference(model: str, payload: dict):
-    """Consulta à HuggingFace Inference API"""
-    if not HF_API_KEY:
-        return {"error": "HF_API_KEY não configurada no ambiente"}
-
-    headers = {"Authorization": f"Bearer {HF_API_KEY}"}
+import requests
+from flask import Flask, request, jsonify
+from flask_cors import CORS
+import firebase_admin
+from firebase_admin import credentials, firestore
+from dotenv import load_dotenv
+
+# Carregar variáveis de ambiente
+load_dotenv()
+
+app = Flask(__name__)
+CORS(app)
+
+# -----------------------------
+# Firebase Setup
+# -----------------------------
+if not firebase_admin._apps:
+    cred = credentials.Certificate("firebase_key.json")  # coloque a chave no container
+    firebase_admin.initialize_app(cred)
+
+db = firestore.client()
+
+# -----------------------------
+# HuggingFace API
+# -----------------------------
+HF_API_URL = os.getenv("HF_API_URL", "https://api-inference.huggingface.co/models/YOUR_MODEL")
+HF_API_KEY = os.getenv("HF_API_KEY")
+
+headers = {"Authorization": f"Bearer {HF_API_KEY}"}
+
+@app.route("/")
+def home():
+    return jsonify({"status": "ok", "message": "MindVoice API online!"})
+
+@app.route("/analyze", methods=["POST"])
+def analyze():
+    """
+    Recebe um áudio ou texto e envia para HuggingFace.
+    Exemplo de payload:
+    {
+        "text": "Estou feliz hoje"
+    }
+    """
     try:
-        async with httpx.AsyncClient(timeout=60) as client:
-            response = await client.post(
-                f"https://api-inference.huggingface.co/models/{model}",
-                headers=headers,
-                json=payload,
-            )
-        if response.status_code != 200:
-            return {"error": f"Erro {response.status_code}: {response.text}"}
-        return response.json()
+        data = request.get_json()
+        if not data:
+            return jsonify({"error": "Payload vazio"}), 400
+
+        # Caso seja texto
+        if "text" in data:
+            payload = {"inputs": data["text"]}
+        else:
+            return jsonify({"error": "Faltando campo 'text'"}), 400
+
+        response = requests.post(HF_API_URL, headers=headers, json=payload, timeout=60)
+        result = response.json()
+
+        # Salvar no Firestore
+        db.collection("insights").add({
+            "text": data["text"],
+            "result": result,
+        })
+
+        return jsonify({"analysis": result})
     except Exception as e:
-        return {"error": f"Falha ao conectar com a Inference API: {str(e)}"}
-
-
-async def translate_to_english(text: str) -> str:
-    """Traduz PT -> EN se necessário"""
-    result = await query_inference(TRANSLATION_MODEL, {"inputs": text})
-    if isinstance(result, list) and result and "translation_text" in result[0]:
-        return result[0]["translation_text"]
-    return text
-
-
-async def classify_emotion(text: str) -> dict:
-    """Classifica emoção e retorna sugestão"""
-    result = await query_inference(EMOTION_MODEL, {"inputs": text})
-
-    if isinstance(result, dict) and "error" in result:
-        return {
-            "emotion": "unknown",
-            "suggestion": "Não foi possível analisar a emoção.",
-            "debug": result,
-        }
-
-    if isinstance(result, list) and result:
-        top_label = result[0]["label"].lower()
-        suggestion = EMOTION_SUGGESTIONS.get(top_label, DEFAULT_SUGGESTION)
-        return {"emotion": top_label, "suggestion": suggestion, "raw": result}
-
-    return {"emotion": "unknown", "suggestion": "Não foi possível analisar a emoção."}
-
+        return jsonify({"error": str(e)}), 500
 
-@app.post("/analyze")
-async def analyze_text(input: TextInput):
-    """Endpoint principal de análise"""
-    text = input.text.strip()
-    # Heurística simples para decidir se traduz
-    if any(c in text for c in "áéíóúãõâêôçà"):
-        text_en = await translate_to_english(text)
-    else:
-        text_en = text
-    return await classify_emotion(text_en)
 
+if __name__ == "__main__":
+    port = int(os.getenv("PORT", 8080))
+    app.run(host="0.0.0.0", port=port, debug=True)
 
-@app.get("/")
-async def root():
-    """Endpoint de saúde"""
-    return {"status": "ok", "message": "API de análise emocional rodando 🚀"}