Update app.py

app.py

@@ -1,179 +1,131 @@
-import os, base64, tempfile, logging, asyncio
+import os, io, base64, tempfile, logging, json, asyncio
+from fastapi import FastAPI, File, UploadFile, HTTPException
+from fastapi.responses import FileResponse, JSONResponse
+from dotenv import load_dotenv
 from faster_whisper import WhisperModel
-from transformers import AutoTokenizer       # ← NOVO
 import google.generativeai as genai
-from flask import Flask, request, jsonify, send_from_directory
-from flask_cors import CORS
-from dotenv import load_dotenv
 import edge_tts
-from asgiref.wsgi import WsgiToAsgi          # Flask → ASGI
 
-# ---------- Configuração ----------
+# ---------- Configuração Inicial ----------
 load_dotenv()
+
 CACHE_DIR = os.getenv("HF_HUB_CACHE", "./models_cache")
 os.environ["MPLCONFIGDIR"] = os.path.join(CACHE_DIR, "matplotlib")
 
 LOGIN_PASSWORDS = os.getenv("LOGIN_PASSWORDS")
-GOOGLE_API_KEY  = os.getenv("GOOGLE_API_KEY")
-
-# ---------- Vocabulário ----------
-# Termos odontológicos mais frequentes
-TERMS_DENTAL = [
-    "odontologia", "dentista", "dente", "gengiva", "periodontite",
-    "gengivite", "cárie", "profilaxia", "halitose", "bruxismo",
-    "restauração", "implante", "tratamento de canal", "pulpite",
-    "estomatite", "afta", "fluorose", "radiografia", "aparelho ortodôntico",
-    "prótese", "clareamento", "raspagem", "tártaro"
-]
-
-# Medicamentos e substâncias de uso rotineiro
-TERMS_MEDS = [
-    "paracetamol", "dipirona", "ibuprofeno", "diclofenaco", "nimesulida",
-    "amoxicilina", "azitromicina", "clindamicina", "clorexidina",
-    "lidocaína", "articaína", "bupivacaína", "cetoprofeno",
-    "cetirizina", "benzocaína", "metronidazol", "prednisona",
-    "dexametasona", "ketorolaco", "omeprazol"
-]
-
-# Junta listas em string único
-_INITIAL_PROMPT_RAW = ", ".join(TERMS_DENTAL + TERMS_MEDS)
-
-# ---------- Tokenizer para garantir ≤224 tokens ----------
-TOKENIZER = AutoTokenizer.from_pretrained("openai/whisper-small")
-MAX_PROMPT_TOKENS = 224
-
-def safe_prompt(text: str) -> str:
-    """Garante que o prompt não exceda 224 tokens do Whisper."""
-    ids = TOKENIZER.encode(text, add_special_tokens=False)
-    return TOKENIZER.decode(ids[-MAX_PROMPT_TOKENS:], skip_special_tokens=True)
-
-INITIAL_PROMPT = safe_prompt(_INITIAL_PROMPT_RAW)
-
-# ---------- Servidor ----------
-app = Flask(__name__)
-CORS(app)
-logging.basicConfig(
-    level=logging.INFO,
-    format="%(asctime)s - %(levelname)s - %(message)s"
-)
-
-logging.info("Carregando modelos…")
-
-# Gemini
+GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")
+
+# ---------- Aplicação FastAPI ----------
+app = FastAPI()
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
+
+# ---------- Carregamento de Modelos (no arranque) ----------
+whisper_model = None
 gemini_model = None
-if GOOGLE_API_KEY:
+
+@app.on_event("startup")
+def load_models():
+    global whisper_model, gemini_model
+    logging.info("A carregar modelos e clientes de API...")
     try:
-        genai.configure(api_key=GOOGLE_API_KEY)
-        gemini_model = genai.GenerativeModel("gemini-1.5-flash")
-        logging.info("Gemini pronto.")
+        model_name = "medium"
+        whisper_model = WhisperModel(model_name, device="cpu", compute_type="int8")
+        logging.info(f"Modelo faster-whisper '{model_name}' (int8) pronto.")
     except Exception as e:
-        logging.error("Falha no Gemini: %s", e)
-
-# Whisper
-try:
-    whisper_model = WhisperModel(
-        "small", device="cpu", compute_type="int8"
-    )
-    logging.info("Whisper pronto.")
-except Exception as e:
-    whisper_model = None
-    logging.error("Falha no Whisper: %s", e)
+        logging.error(f"Falha ao iniciar o modelo faster-whisper: {e}")
+        raise RuntimeError("Não foi possível carregar o modelo Whisper.") from e
+
+    if GOOGLE_API_KEY:
+        try:
+            genai.configure(api_key=GOOGLE_API_KEY)
+            gemini_model = genai.GenerativeModel("gemini-1.5-flash")
+            logging.info("Gemini pronto.")
+        except Exception as e:
+            logging.error(f"Falha ao iniciar Gemini: {e}")
+            raise RuntimeError("Não foi possível carregar o modelo Gemini.") from e
+    logging.info("Modelos carregados com sucesso.")
+
 
 # ---------- Utilidades ----------
 def ask_gemini(question: str) -> str:
     if not gemini_model:
-        return ("Desculpe, o serviço de IA não está disponível.")
-    system_prompt = (
-        "Você é 'SintonIA', assistente de saúde bucal. "
-        "Responda em 2–3 frases, com empatia, sem diagnosticar, "
-        "e incentive consulta presencial ao dentista."
-    )
+        raise HTTPException(status_code=503, detail="Modelo de linguagem não está disponível.")
+    prompt = ("Você é 'SintonIA', um assistente de IA por voz para saúde bucal. "
+              "Responda de forma empática, clara e segura, em 2-3 frases. "
+              "NUNCA dê diagnóstico e sempre recomende consulta presencial a um dentista.")
     try:
-        resp = gemini_model.generate_content([system_prompt, question])
-        return resp.text
+        response = gemini_model.generate_content([prompt, question])
+        return response.text
     except Exception as e:
-        logging.error("Erro no Gemini: %s", e)
-        return ("Desculpe, ocorreu um erro ao gerar a resposta.")
+        logging.error(f"Erro no Gemini: {e}")
+        raise HTTPException(status_code=500, detail="Erro ao gerar a resposta de IA.")
 
 VOICE = "pt-BR-AntonioNeural"
 async def synthesize(text: str) -> bytes | None:
     try:
-        audio = b""
+        audio_bytes = b""
         communicate = edge_tts.Communicate(text, VOICE)
         async for chunk in communicate.stream():
             if chunk["type"] == "audio":
-                audio += chunk["data"]
-        return audio
+                audio_bytes += chunk["data"]
+        return audio_bytes
     except Exception as e:
-        logging.error("Erro no TTS: %s", e)
+        logging.error(f"Erro ao sintetizar áudio com Edge TTS: {e}")
         return None
 
-# ---------- Rotas ----------
-@app.route("/")
-def index():
-    return send_from_directory(".", "index.html")
+# ---------- Rotas (Endpoints) ----------
+@app.get("/")
+async def read_index():
+    return FileResponse('index.html')
 
-@app.route("/login", methods=["POST"])
-def login():
+@app.post("/login")
+async def login(request: dict):
     if not LOGIN_PASSWORDS:
-        return jsonify(success=True)
-    valid = [p.strip() for p in LOGIN_PASSWORDS.split(",")]
-    ok = (request.json or {}).get("password", "") in valid
-    return jsonify(success=ok), (200 if ok else 401)
-
-@app.route("/process-audio", methods=["POST"])
-async def process_audio():
-    if "audio" not in request.files:
-        return jsonify(error="Nenhum áudio enviado."), 400
-    if not whisper_model:
-        return jsonify(error="ASR indisponível."), 500
-
-    audio_file = request.files["audio"]
-    with tempfile.NamedTemporaryFile(suffix=".webm", delete=True) as tmp:
-        audio_file.save(tmp.name)
-
-        # 1ª tentativa — com initial_prompt
-        try:
-            segments, _ = whisper_model.transcribe(
-                tmp.name, language="pt", initial_prompt=INITIAL_PROMPT
-            )
-            text = "".join(s.text for s in segments).strip()
-        except Exception as e:
-            logging.warning("Falha com prompt: %s; tentando sem.", e)
-            text = ""
-
-        # Fallback sem prompt
-        if not text:
-            try:
-                segments, _ = whisper_model.transcribe(
-                    tmp.name, language="pt"
-                )
-                text = "".join(s.text for s in segments).strip()
-            except Exception as e:
-                logging.error("Falha sem prompt: %s", e)
-                return jsonify(error="Erro na transcrição."), 500
-
-    # Se ainda vazio, devolve pedido de repetição
+        return {"success": True}
+    valid_passwords = [p.strip() for p in LOGIN_PASSWORDS.split(',')]
+    pwd_received = request.get("password", "")
+    is_ok = pwd_received in valid_passwords
+    if not is_ok:
+        raise HTTPException(status_code=401, detail="Senha incorreta.")
+    return {"success": True}
+
+@app.post("/process-audio")
+async def process_audio(audio: UploadFile = File(...)):
+    if not all([whisper_model, gemini_model]):
+        raise HTTPException(status_code=503, detail="Um serviço de IA não está disponível.")
+
+    try:
+        with tempfile.NamedTemporaryFile(delete=True, suffix=".webm") as tmp_file:
+            content = await audio.read()
+            tmp_file.write(content)
+            tmp_file.seek(0)
+            
+            if os.path.getsize(tmp_file.name) > 1000:
+                segments, _ = whisper_model.transcribe(tmp_file.name, language="pt")
+                transcribed_parts = [segment.text for segment in segments]
+                text = "".join(transcribed_parts).strip()
+                logging.info(f"Texto transcrito: '{text}'")
+            else:
+                text = ""
+    except Exception as e:
+        logging.error(f"Erro na transcrição do faster-whisper: {e}")
+        text = ""
+
     if not text:
-        ai_text = ("Desculpe, não entendi o que foi dito. "
-                   "Você poderia repetir, por favor?")
+        ai_text = "Desculpe, não entendi o que foi dito. Você poderia repetir, por favor?"
     else:
         ai_text = ask_gemini(text)
 
-    audio_bytes = await synthesize(ai_text) if ai_text else None
-
-    return jsonify(
-        user_question=text,
-        ai_answer=ai_text,
-        audio_base64=(
-            base64.b64encode(audio_bytes).decode()
-            if audio_bytes else None
-        )
-    )
+    audio_bytes = None
+    if ai_text:
+        audio_bytes = await synthesize(ai_text)
 
-@app.route("/healthz")
-def healthz():
-    return "OK", 200
+    return JSONResponse(content={
+        "user_question": text,
+        "ai_answer": ai_text,
+        "audio_base64": base64.b64encode(audio_bytes).decode('utf-8') if audio_bytes else None
+    })
 
-# ---------- ASGI ----------
-asgi_app = WsgiToAsgi(app)
+@app.get("/healthz")
+async def health_check():
+    return {"status": "OK"}