new app

app.py

@@ -1,16 +1,30 @@
-# app.py – Transcrição Inteligente de Consultas Médicas em Tempo Real
-# Autor: OpenAI ChatGPT (o3)
 """
-Este aplicativo Gradio roda em um Hugging Face Space e demonstra:
-  • Captura de áudio do microfone em tempo real
-  • Envio de chunks para a Realtime API da OpenAI (modelo gpt‑4o‑transcribe)
-  • Exibição da transcrição ao vivo
-  • Resumo de ~60 s em bullet points
-  • Geração de nota SOAP final
-  • Download do áudio e botão para copiar texto
-
-⚠️ Este código é um protótipo de referência. Em produção, trate PHI com rigor, use
-chaves de API via Secrets do Space e adicione controle de erros mais robusto.
+MedBuddy: Transcrição Médica em Tempo Real com OpenAI e Gradio
+
+Versão: 2.0
+Data: 20/07/2025
+
+Este aplicativo Gradio, projetado para rodar em um Hugging Face Space, demonstra
+um pipeline de transcrição e sumarização de consultas médicas em tempo real.
+
+Funcionalidades:
+  - Captura de áudio do microfone via streaming.
+  - Transcrição ao vivo usando a Realtime API da OpenAI (gpt-4o-realtime).
+  - Geração de resumos periódicos em "bullet points" (gpt-4o-mini).
+  - Elaboração de uma nota final no formato SOAP (gpt-4o).
+  - Interface limpa com componentes nativos para copiar texto e baixar o áudio.
+
+Requisitos:
+  - gradio
+  - openai
+  - websockets
+  - soundfile
+  - numpy
+
+⚠️ AVISO: Este código é um protótipo de referência. Para uso em produção,
+é mandatório tratar informações de saúde protegidas (PHI) com o máximo rigor,
+utilizar o sistema de Secrets do Hugging Face para chaves de API e implementar
+um tratamento de erros mais abrangente.
 """
 
 import asyncio
@@ -18,7 +32,6 @@ import json
 import os
 import tempfile
 import time
-from datetime import datetime
 
 import gradio as gr
 import numpy as np
@@ -26,213 +39,262 @@ import openai
 import soundfile as sf
 import websockets
 
-# -------------------------------------------------------
+# -------------------------------------------------------------------
 # Configuração
-# -------------------------------------------------------
+# -------------------------------------------------------------------
+# Chave de API da OpenAI (carregada a partir dos Secrets do HF Space)
 OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
 if not OPENAI_API_KEY:
-    raise RuntimeError("Defina OPENAI_API_KEY nas variáveis de ambiente ou Secrets do HF Space!")
-
+    raise ValueError("A variável de ambiente OPENAI_API_KEY não foi definida.")
 openai.api_key = OPENAI_API_KEY
 
-STT_MODEL = "gpt-4o-realtime-preview-2025-06-03"  # modelo de transcrição
-SUMMARY_MODEL = "gpt-4o-mini"                      # bullet points minuto a minuto
-SOAP_MODEL = "gpt-4o"                              # sumário final SOAP
-SAMPLE_RATE = 16000                                # Hz, mono
-SUMMARY_EVERY_SEC = 60                             # janela de resumo
-
-# -------------------------------------------------------
-# Estado de sessão (single‑user Space simplificado)
-# -------------------------------------------------------
+# Modelos da OpenAI (verificar documentação para os nomes mais recentes)
+STT_MODEL = "gpt-4o-realtime-preview-2025-06-03"
+SUMMARY_MODEL = "gpt-4o-mini"
+SOAP_MODEL = "gpt-4o"
+
+# Configurações de áudio
+SAMPLE_RATE = 16000  # Hz
+SUMMARY_EVERY_SEC = 60  # Gerar resumo a cada 60 segundos
+
+# -------------------------------------------------------------------
+# Gerenciamento de Estado da Sessão
+# -------------------------------------------------------------------
+# Nota: Para um ambiente multiusuário, o ideal é usar `gr.State`
+# para gerenciar o estado de cada sessão individualmente.
+# Para este demo de usuário único, uma classe global simplifica o código.
 class SessionState:
+    """Encapsula o estado de uma sessão de gravação ativa."""
     def __init__(self):
-        self.ws = None               # conexão WebSocket com API Realtime
-        self.running = False         # flag de captura
-        self.transcript_full = ""     # transcrição acumulada
-        self.bullets = []            # lista de bullets
-        self.last_summary_ts = time.time()
-        self.audio_chunks = []       # lista de arrays numpy
-        self.contexto = ""           # texto inserido pelo usuário
+        self.ws: websockets.WebSocketClientProtocol | None = None
+        self.running: bool = False
+        self.transcript_full: str = ""
+        self.bullets: list[str] = []
+        self.last_summary_ts: float = 0.0
+        self.audio_chunks: list[np.ndarray] = []
+        self.contexto: str = ""
 
 state = SessionState()
 
-# -------------------------------------------------------
-# Funções auxiliares – OpenAI Realtime API
-# -------------------------------------------------------
+# -------------------------------------------------------------------
+# Funções de Comunicação com a API OpenAI
+# -------------------------------------------------------------------
 async def open_realtime_ws() -> websockets.WebSocketClientProtocol:
-    """Abre e retorna a conexão WebSocket com a Realtime API."""
-    uri = f"wss://api.openai.com/v1/realtime?model={STT_MODEL}"
-    ws = await websockets.connect(
-        uri,
-        extra_headers={
-            "Authorization": f"Bearer {OPENAI_API_KEY}",
-            "OpenAI-Beta": "realtime=v1",
-        },
-        subprotocols=["realtime"],
-        max_size=1 * 1024 * 1024,  # 1 MB
-    )
-
-    # Primeiro evento deve ser session.created
-    evt = json.loads(await ws.recv())
-    if evt.get("type") != "session.created":
-        raise RuntimeError(f"Evento inicial inesperado: {evt}")
-    return ws
+    """Abre e valida a conexão WebSocket com a Realtime API."""
+    uri = f"wss://api.openai.com/v1/realtime?model={STT_MODEL}&sample_rate={SAMPLE_RATE}"
+    try:
+        ws = await websockets.connect(
+            uri,
+            extra_headers={"Authorization": f"Bearer {OPENAI_API_KEY}"},
+            subprotocols=["realtime"],
+            max_size=2 * 1024 * 1024,  # 2 MB
+        )
+        # O primeiro evento deve ser a confirmação da criação da sessão
+        evt = json.loads(await asyncio.wait_for(ws.recv(), timeout=10))
+        if evt.get("type") != "session.created":
+            raise ConnectionRefusedError(f"Falha ao criar sessão: {evt}")
+        return ws
+    except Exception as e:
+        print(f"Erro ao conectar ao WebSocket: {e}")
+        raise
 
 async def pcm_from_numpy(chunk: np.ndarray) -> bytes:
-    """Converte numpy float32 (-1..1) → bytes PCM 16‑bit LE."""
+    """Converte um array numpy float32 para bytes no formato PCM 16-bit little-endian."""
+    # Garante que o array é float32 e está no range [-1, 1]
     if chunk.dtype != np.float32:
         chunk = chunk.astype(np.float32)
-    pcm16 = (np.clip(chunk, -1, 1) * 32767).astype(np.int16)
+    chunk = np.clip(chunk, -1.0, 1.0)
+    
+    # Converte para int16
+    pcm16 = (chunk * 32767).astype(np.int16)
     return pcm16.tobytes()
 
-async def send_audio_chunk(chunk: np.ndarray, ws: websockets.WebSocketClientProtocol):
-    await ws.send(await pcm_from_numpy(chunk))
-
-# -------------------------------------------------------
-# Funções de resumo / SOAP (Chat Completions)
-# -------------------------------------------------------
+# -------------------------------------------------------------------
+# Funções de Geração de Texto (Sumário e SOAP)
+# -------------------------------------------------------------------
 async def summarize_block(text: str) -> str:
-    """Gera até 5 bullet points em PT‑BR para o bloco de texto fornecido."""
-    rsp = openai.chat.completions.create(
-        model=SUMMARY_MODEL,
-        messages=[
-            {
-                "role": "system",
-                "content": "Você é escriba clínico. Resuma o texto a seguir em até 5 bullet points concisos, em português.",
-            },
-            {"role": "user", "content": text},
-        ],
-        temperature=0.3,
-    )
-    return rsp.choices[0].message.content.strip()
+    """Gera um resumo conciso (bullet points) para um trecho da transcrição."""
+    if not text.strip():
+        return ""
+    try:
+        response = await openai.chat.completions.create(
+            model=SUMMARY_MODEL,
+            messages=[
+                {"role": "system", "content": "Você é um escriba clínico. Resuma o texto a seguir em até 5 bullet points concisos, em português do Brasil."},
+                {"role": "user", "content": text},
+            ],
+            temperature=0.3,
+            max_tokens=200,
+        )
+        return response.choices[0].message.content.strip()
+    except Exception as e:
+        print(f"Erro ao gerar sumário: {e}")
+        return "[Erro ao gerar sumário parcial]"
 
 async def generate_soap(full_txt: str, bullets: list[str], contexto: str) -> str:
-    """Combina transcript + bullets + contexto para gerar nota SOAP final."""
-    rsp = openai.chat.completions.create(
-        model=SOAP_MODEL,
-        messages=[
-            {"role": "system", "content": "Você é um escriba médico sênior."},
-            {"role": "user", "content": f"Contexto: {contexto}"},
-            {"role": "assistant", "content": "\n".join(bullets)},
-            {
-                "role": "user",
-                "content": (
-                    "Transcrição completa a seguir. Elabore a nota final no formato SOAP, em português, "
-                    "utilizando os bullet points como guia.\n\n" + full_txt
-                ),
-            },
-        ],
-        temperature=0.2,
-    )
-    return rsp.choices[0].message.content.strip()
-
-# -------------------------------------------------------
-# Callbacks Gradio
-# -------------------------------------------------------
+    """Gera a nota final no formato SOAP a partir do contexto e da transcrição."""
+    if not full_txt.strip():
+        return "Nenhuma transcrição foi gerada para criar a nota SOAP."
+        
+    bullet_summary = "\n".join(bullets)
+    prompt_context = f"Contexto prévio da consulta: {contexto if contexto else 'Nenhum'}"
+    
+    try:
+        response = await openai.chat.completions.create(
+            model=SOAP_MODEL,
+            messages=[
+                {"role": "system", "content": "Você é um assistente médico sênior especializado em documentação clínica. Sua tarefa é criar uma nota no formato SOAP (Subjetivo, Objetivo, Avaliação, Plano) baseada na transcrição da consulta."},
+                {"role": "user", "content": f"{prompt_context}\n\nResumo dos pontos chave (para guia):\n{bullet_summary}\n\nUse a transcrição completa a seguir para elaborar a nota SOAP final em português do Brasil, de forma estruturada e profissional:\n\n---\n{full_txt}"},
+            ],
+            temperature=0.2,
+            max_tokens=1500,
+        )
+        return response.choices[0].message.content.strip()
+    except Exception as e:
+        print(f"Erro ao gerar nota SOAP: {e}")
+        return f"[Erro ao gerar nota SOAP final]\n\nTranscrição completa:\n{full_txt}"
+
+# -------------------------------------------------------------------
+# Callbacks da Interface Gradio
+# -------------------------------------------------------------------
 async def cb_start(contexto: str):
-    """Inicia gravação: abre WS, reseta estados."""
+    """Callback: Inicia a gravação."""
     if state.running:
-        return gr.update(value="Já gravando...")
-
-    state.__init__()  # reset
+        return
+    
+    state.__init__()  # Reseta o estado da sessão
     state.contexto = contexto
     state.running = True
-    state.ws = await open_realtime_ws()
-    state.last_summary_ts = time.time()
-    return gr.update(value="Gravando… (clique em Finalizar para encerrar)")
-
-async def cb_stream(audio_chunk, live_txt, live_sum):
-    """Callback contínuo do componente de microfone (streaming=True)."""
-    if not state.running or audio_chunk is None:
+    
+    try:
+        state.ws = await open_realtime_ws()
+        state.last_summary_ts = time.time()
+        print("Sessão de gravação iniciada.")
+        # Limpa os campos da UI
+        return "", "", "", None
+    except Exception as e:
+        state.running = False
+        gr.Warning(f"Não foi possível iniciar a gravação: {e}")
+        return "", "", "", None
+
+async def cb_stream(audio_stream, live_txt, live_sum):
+    """Callback: Processa o stream de áudio em tempo real."""
+    if not state.running or audio_stream is None or not state.ws:
         return live_txt, live_sum
 
-    # Garantir mono
-    if audio_chunk.ndim == 2:
-        audio_chunk = audio_chunk.mean(axis=1)
-
-    # Envia chunk para a API e guarda localmente
-    await send_audio_chunk(audio_chunk, state.ws)
-    state.audio_chunks.append(audio_chunk)
-
-    # Tenta ler rapidamente novos transcripts (non‑blocking)
     try:
-        for _ in range(5):
-            msg = await asyncio.wait_for(state.ws.recv(), timeout=0.01)
-            evt = json.loads(msg)
-            if evt.get("type") == "transcript":
-                txt = evt["transcript"]["text"]
-                state.transcript_full += txt + " "
-    except (asyncio.TimeoutError, websockets.exceptions.ConnectionClosedOK):
-        pass
-
-    # Resumo a cada SUMMARY_EVERY_SEC
-    now = time.time()
-    if now - state.last_summary_ts >= SUMMARY_EVERY_SEC:
-        bullet = await summarize_block(state.transcript_full[-4000:])
-        state.bullets.append(bullet)
-        state.last_summary_ts = now
-
-    live_summary_md = "\n\n".join(state.bullets)
-    return state.transcript_full, live_summary_md
+        await state.ws.send(await pcm_from_numpy(audio_stream))
+        state.audio_chunks.append(audio_stream)
+
+        # Processa mensagens recebidas do WebSocket de forma não-bloqueante
+        while True:
+            try:
+                msg = await asyncio.wait_for(state.ws.recv(), timeout=0.01)
+                evt = json.loads(msg)
+                if evt.get("type") == "transcript" and (text := evt.get("transcript", {}).get("text")):
+                    state.transcript_full += text + " "
+            except asyncio.TimeoutError:
+                break  # Não há mais mensagens no buffer, sai do loop
+
+        # Gera resumo periódico
+        if (time.time() - state.last_summary_ts) >= SUMMARY_EVERY_SEC:
+            # Pega os últimos ~4000 caracteres para o resumo parcial
+            transcript_slice = state.transcript_full[-4000:]
+            bullet = await summarize_block(transcript_slice)
+            if bullet:
+                state.bullets.append(bullet)
+                state.last_summary_ts = time.time()
+                
+        live_summary_md = "\n\n".join(state.bullets)
+        return state.transcript_full, live_summary_md
+
+    except (websockets.exceptions.ConnectionClosed, Exception) as e:
+        print(f"Erro durante o streaming: {e}")
+        await cb_stop()  # Tenta finalizar a sessão de forma limpa
+        return live_txt, live_sum
 
-async def cb_stop():
-    """Finaliza gravação, gera SOAP e disponibiliza download do áudio."""
+async def cb_stop(audio_filepath):
+    """Callback: Finaliza a gravação, gera a nota SOAP e prepara o download."""
     if not state.running:
-        return "", "", ""
+        return "", None  # Retorna valores para sumário final e botão de download
 
+    print("Finalizando a gravação...")
     state.running = False
     if state.ws:
         await state.ws.close()
 
-    # Garantir último resumo se necessário
+    # Gera um último resumo se houver transcrição nova
     if state.transcript_full and (not state.bullets or (time.time() - state.last_summary_ts) > 15):
         bullet = await summarize_block(state.transcript_full[-4000:])
-        state.bullets.append(bullet)
-
-    soap = await generate_soap(state.transcript_full, state.bullets, state.contexto)
-
-    # Salvar áudio
-    wav_path = tempfile.mktemp(suffix=".wav", prefix="consulta_")
-    if state.audio_chunks:
-        audio_np = np.concatenate(state.audio_chunks)
-        sf.write(wav_path, audio_np, SAMPLE_RATE)
-
-    # Botões de download/cópia
-    download_link = f"<a href='file={wav_path}' download>Baixar áudio (.wav)</a>"
-
-# escapa crases e aspas duplas para não quebrar o JS
-    escaped_soap = soap.replace('`', '\\`').replace('"', '\\"')
-
-    copy_btn = (
-        f'<button onclick="navigator.clipboard.writeText(`{escaped_soap}`)">Copiar SOAP</button>'
-        )
-
-    soap_html = f"<h3>Nota SOAP</h3><pre>{soap}</pre>{download_link}<br>{copy_btn}"
-    return state.transcript_full, "\n\n".join(state.bullets), soap_html
-
-# -------------------------------------------------------
-# Interface Gradio
-# -------------------------------------------------------
-with gr.Blocks(title="Transcrição Inteligente – Demo") as demo:
-    gr.Markdown("## Transcrição inteligente de consultas médicas em tempo real")
-
-    with gr.Row():
-        contexto_txt = gr.Textbox(label="Contexto da consulta (opcional)", lines=2, placeholder="Ex.: Paciente com dispneia crônica...")
-        btn_start = gr.Button("Iniciar", variant="primary")
-        btn_stop = gr.Button("Finalizar", variant="stop")
-
-    with gr.Row():
-        md_transcript = gr.Markdown("", label="Transcrição em tempo real")
-        md_summary = gr.Markdown("", label="Resumo (bullet points)")
-
-    md_soap = gr.HTML("", label="Nota SOAP final")
-
-    mic = gr.Audio(sources=["microphone"], type="numpy", streaming=True, label="Microfone (16 kHz)")
-
-    # Eventos
-    btn_start.click(cb_start, inputs=[contexto_txt], outputs=[btn_start])
-    mic.stream(cb_stream, inputs=[mic, md_transcript, md_summary], outputs=[md_transcript, md_summary])
-    btn_stop.click(cb_stop, inputs=None, outputs=[md_transcript, md_summary, md_soap])
+        if bullet:
+            state.bullets.append(bullet)
+
+    soap_note = await generate_soap(state.transcript_full, state.bullets, state.contexto)
+
+    # O `audio_filepath` já é fornecido pelo Gradio quando `type="filepath"`
+    # e `stop_recording` é acionado. Não precisamos mais montar o áudio manualmente.
+    print(f"Áudio final salvo em: {audio_filepath}")
+    
+    return soap_note, audio_filepath
+
+# -------------------------------------------------------------------
+# Definição da Interface Gráfica (Gradio)
+# -------------------------------------------------------------------
+with gr.Blocks(theme=gr.themes.Soft(), title="MedBuddy – Transcrição Médica") as demo:
+    gr.Markdown("# MedBuddy")
+    gr.Markdown("### Um Modelo Open-Source de Transcrição Inteligente de Consultas Médicas")
+
+    with gr.Tabs():
+        with gr.TabItem("Gravação e Transcrição"):
+            contexto_txt = gr.Textbox(
+                label="Contexto da Consulta (opcional)",
+                lines=3,
+                placeholder="Ex.: Paciente com histórico de dispneia crônica, fumante há 20 anos, apresentando tosse persistente."
+            )
+            
+            mic_audio = gr.Audio(
+                sources=["microphone"],
+                type="filepath",  # 'filepath' é ideal para o botão de download
+                label="Microfone (16kHz)",
+                streaming=True,
+            )
+
+            with gr.Row():
+                transcricao_txt = gr.Textbox(label="Transcrição em Tempo Real", lines=15, interactive=False)
+                sumario_basico_txt = gr.Textbox(label="Resumo (Bullet Points)", lines=15, interactive=False)
+            
+            with gr.Accordion("Resultados Finais", open=False):
+                sumario_final_txt = gr.Textbox(
+                    label="Nota SOAP Final", 
+                    lines=15, 
+                    interactive=False, 
+                    show_copy_button=True
+                )
+                baixar_btn = gr.DownloadButton(
+                    "Baixar Áudio (.wav)",
+                    interactive=True
+                )
+
+    # ---------------------------------------------------------------
+    # Lógica de Eventos da Interface
+    # ---------------------------------------------------------------
+    mic_audio.start_recording(
+        fn=cb_start,
+        inputs=[contexto_txt],
+        outputs=[transcricao_txt, sumario_basico_txt, sumario_final_txt, baixar_btn]
+    )
+    
+    mic_audio.stream(
+        fn=cb_stream,
+        inputs=[mic_audio, transcricao_txt, sumario_basico_txt],
+        outputs=[transcricao_txt, sumario_basico_txt]
+    )
+    
+    mic_audio.stop_recording(
+        fn=cb_stop,
+        inputs=[mic_audio],
+        outputs=[sumario_final_txt, baixar_btn]
+    )
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch(debug=True)

requirements.txt

@@ -1,5 +1,5 @@
-openai
 gradio
-websockets
+openai>=1.0.0
+websockets>=10.0
 soundfile
 numpy