Gerador de vídeos narrativos (Godot + FFmpeg), painel Next.js, serviço de voz, Clipador de lives e Publicador para YouTube, TikTok e Instagram. Inclui a leitura das visualizações dos posts para o Dashboard e o botão "Publicar no <rede>" nos cartões das publicações. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
97 lines
4.1 KiB
Python
97 lines
4.1 KiB
Python
"""Teste de fumaça do serviço de voz rodando (porta 4510): status, síntese de cada voz e transcrição com tempos.
|
|
|
|
Uso: voice/.venv/Scripts/python voice/scripts/smoke.py [--out output/voice-smoke]
|
|
Lê a chave do voice/.env. Grava os WAV gerados e o JSON da transcrição na pasta de saída.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import argparse
|
|
import json
|
|
import os
|
|
import sys
|
|
import time
|
|
import urllib.error
|
|
import urllib.request
|
|
from pathlib import Path
|
|
|
|
VOICE_ROOT = Path(__file__).resolve().parent.parent
|
|
sys.path.insert(0, str(VOICE_ROOT))
|
|
from app.config import PROJECT_ROOT, load_dotenv # noqa: E402
|
|
|
|
TEXT = "Olá! Este é o serviço de voz do CenaForge, gerando a narração do episódio."
|
|
|
|
|
|
def call(method: str, path: str, key: str, port: int, body: bytes | None = None, headers: dict | None = None):
|
|
request = urllib.request.Request(
|
|
f"http://127.0.0.1:{port}{path}", data=body, method=method,
|
|
headers={"X-Service-Key": key, **(headers or {})},
|
|
)
|
|
try:
|
|
with urllib.request.urlopen(request, timeout=300) as response: # noqa: S310 - localhost fixo
|
|
return response.status, {k.lower(): v for k, v in response.headers.items()}, response.read()
|
|
except urllib.error.HTTPError as error:
|
|
return error.code, {k.lower(): v for k, v in error.headers.items()}, error.read()
|
|
|
|
|
|
def main() -> int:
|
|
parser = argparse.ArgumentParser()
|
|
parser.add_argument("--out", default=str(PROJECT_ROOT / "output" / "voice-smoke"))
|
|
parser.add_argument("--detail", default="words", choices=("text", "segments", "words"))
|
|
args = parser.parse_args()
|
|
load_dotenv(VOICE_ROOT / ".env")
|
|
key = os.environ["VOICE_SERVICE_KEY"]
|
|
port = int(os.environ.get("VOICE_PORT", "4510"))
|
|
out = Path(args.out)
|
|
out.mkdir(parents=True, exist_ok=True)
|
|
|
|
status, _, raw = call("GET", "/v1/status", key, port)
|
|
data = json.loads(raw)
|
|
print(f"status {status}: dispositivo={data['device']} rvc={data['rvc']} motores={data['engines']}")
|
|
|
|
voices = json.loads(call("GET", "/v1/voices", key, port)[2])["items"]
|
|
first_wav: Path | None = None
|
|
for voice in voices:
|
|
request_id = f"smoke-{voice['id']}-{int(time.time())}"
|
|
payload = {"requestId": request_id[:64], "text": TEXT, "voiceId": voice["id"], "params": {"format": "wav"}}
|
|
started = time.perf_counter()
|
|
code, headers, audio = call(
|
|
"POST", "/v1/synthesize", key, port, json.dumps(payload).encode(), {"Content-Type": "application/json"}
|
|
)
|
|
wall = time.perf_counter() - started
|
|
if code != 200:
|
|
print(f" {voice['id']}: ERRO {code} {audio[:200]!r}")
|
|
continue
|
|
target = out / f"{voice['id']}.wav"
|
|
target.write_bytes(audio)
|
|
first_wav = first_wav or target
|
|
print(f" {voice['id']} ({voice.get('provider')}): {headers.get('x-audio-duration-ms')} ms de áudio "
|
|
f"em {wall:.2f} s -> {target}")
|
|
|
|
if first_wav is None:
|
|
print("nenhuma voz gerou áudio")
|
|
return 1
|
|
audio = first_wav.read_bytes()
|
|
duration_ms = max(1, int((len(audio) - 44) / 2 / 24000 * 1000)) # WAV PCM16 mono; só uma estimativa
|
|
started = time.perf_counter()
|
|
code, _, raw = call("POST", "/v1/transcribe", key, port, audio, {
|
|
"Content-Type": "audio/wav", "X-Idempotency-Key": f"smoke-{int(time.time())}",
|
|
"X-Audio-Duration-Ms": str(duration_ms), "X-Language": "pt-BR", "X-Detail": args.detail,
|
|
})
|
|
result = json.loads(raw)
|
|
while code == 202:
|
|
time.sleep(result["retryAfterMs"] / 1000)
|
|
code, _, raw = call("GET", f"/v1/transcribe/jobs/{result['jobRef']}", key, port)
|
|
result = json.loads(raw)
|
|
wall = time.perf_counter() - started
|
|
(out / "transcribe.json").write_text(json.dumps(result, ensure_ascii=False, indent=2), encoding="utf-8")
|
|
print(f"transcrição {code} em {wall:.2f} s: {result.get('text')!r}")
|
|
if result.get("segments"):
|
|
words = [w for s in result["segments"] for w in s.get("words", [])]
|
|
print(f" {len(result['segments'])} segmento(s), {len(words)} palavra(s) com tempo")
|
|
return 0 if code == 200 else 1
|
|
|
|
|
|
if __name__ == "__main__":
|
|
raise SystemExit(main())
|