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>
216 lines
9.7 KiB
Python
216 lines
9.7 KiB
Python
"""Configuração do serviço de voz do CenaForge, lida de variáveis de ambiente e de `voice/.env`.
|
||
|
||
Roda nativo no PC (sem Docker): as pastas padrão ficam em `data/voice/` na raiz do projeto.
|
||
Falha fechado: sem chave de serviço forte o processo não sobe (o setup gera uma no `voice/.env`).
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
import os
|
||
from dataclasses import dataclass
|
||
from pathlib import Path
|
||
|
||
MIN_KEY_LENGTH = 32
|
||
# Variáveis que deixaram de valer: a fila virou cota por chave (`*_PER_KEY`). Avisamos no boot para o
|
||
# operador não achar que o valor antigo continua limitando alguma coisa.
|
||
# Timeout do cliente HTTP (painel e render do CenaForge). A síntese é síncrona: espera na fila + execução
|
||
# precisa caber nele, ou o cliente desiste antes da resposta.
|
||
BACKEND_CLIENT_TIMEOUT_S = 300.0
|
||
VOICE_ROOT = Path(__file__).resolve().parent.parent
|
||
PROJECT_ROOT = VOICE_ROOT.parent
|
||
STT_MODELS = ("base", "small", "medium", "large-v3-turbo")
|
||
DEVICES = ("auto", "cuda", "cpu")
|
||
# A espera na fila precisa cobrir pelo menos este múltiplo da execução: com a CPU em rodízio, a outra chave pode
|
||
# pegar um trabalho no teto na frente (e a vaga só volta quando a thread termina, um pouco depois do teto).
|
||
QUEUE_TO_RUN_RATIO = 2.0
|
||
RETIRED_VARS = {"VOICE_MAX_QUEUE": "VOICE_MAX_QUEUE_PER_KEY", "VOICE_STT_MAX_QUEUE": "VOICE_STT_MAX_QUEUE_PER_KEY"}
|
||
|
||
|
||
class ConfigError(RuntimeError):
|
||
"""Configuração inválida; o serviço não deve subir."""
|
||
|
||
|
||
def load_dotenv(path: Path) -> None:
|
||
"""Carrega `CHAVE=valor` de um arquivo .env sem sobrescrever o que já está no ambiente."""
|
||
if not path.is_file():
|
||
return
|
||
for line in path.read_text(encoding="utf-8").splitlines():
|
||
line = line.strip()
|
||
if not line or line.startswith("#") or "=" not in line:
|
||
continue
|
||
name, value = line.split("=", 1)
|
||
os.environ.setdefault(name.strip(), value.strip().strip('"').strip("'"))
|
||
|
||
|
||
def _path(name: str, default: Path) -> Path:
|
||
raw = os.environ.get(name, "")
|
||
if not raw:
|
||
return default
|
||
value = Path(raw)
|
||
return value if value.is_absolute() else PROJECT_ROOT / value
|
||
|
||
|
||
def _int(name: str, default: int, minimum: int = 1) -> int:
|
||
raw = os.environ.get(name)
|
||
value = default if raw in (None, "") else int(raw)
|
||
if value < minimum:
|
||
raise ConfigError(f"{name} precisa ser >= {minimum}")
|
||
return value
|
||
|
||
|
||
def _float(name: str, default: float, minimum: float = 0.1) -> float:
|
||
raw = os.environ.get(name)
|
||
value = default if raw in (None, "") else float(raw)
|
||
if value < minimum:
|
||
raise ConfigError(f"{name} precisa ser >= {minimum}")
|
||
return value
|
||
|
||
|
||
def _azure_region() -> str:
|
||
region = os.environ.get("VOICE_AZURE_REGION", "eastus").strip().lower() or "eastus"
|
||
if not region.isascii() or not region.isalnum():
|
||
raise ConfigError(f"VOICE_AZURE_REGION inválida: {region!r} (ex.: eastus, brazilsouth)")
|
||
return region
|
||
|
||
|
||
def _clone_port() -> int:
|
||
port = _int("VOICE_CLONE_PORT", 4511)
|
||
if not 4500 <= port <= 4599:
|
||
raise ConfigError(f"VOICE_CLONE_PORT={port} fora da faixa 4500–4599 do CenaForge")
|
||
return port
|
||
|
||
|
||
def _choice(name: str, default: str, allowed: tuple[str, ...]) -> str:
|
||
value = os.environ.get(name) or default
|
||
if value not in allowed:
|
||
raise ConfigError(f"{name} precisa ser um de {allowed}")
|
||
return value
|
||
|
||
|
||
@dataclass(frozen=True)
|
||
class Settings:
|
||
service_key: str
|
||
models_dir: Path
|
||
data_dir: Path
|
||
catalog_path: Path
|
||
lock_path: Path
|
||
max_concurrency: int = 1
|
||
# Cota de espera POR CHAVE de serviço: a fila cheia de uma chave nunca recusa a outra.
|
||
max_queue_per_key: int = 8
|
||
# Uma fala de episódio (até 2 min) com RVC em CPU leva ~1 min. 180 + 90 = 270 s < 300 s do cliente.
|
||
queue_timeout_s: float = 180.0
|
||
synth_timeout_s: float = 90.0
|
||
max_text_chars: int = 2000
|
||
max_audio_s: float = 120.0
|
||
cache_max_mb: int = 512
|
||
idempotency_ttl_h: int = 72
|
||
onnx_threads: int = 2
|
||
opus_bitrate: int = 48000
|
||
verify_models: bool = True
|
||
enable_rvc: bool = False
|
||
# Azure Speech (opcional): sem chave, as vozes do motor azure ficam fora do catálogo.
|
||
azure_key: str = ""
|
||
azure_region: str = "eastus"
|
||
# Processo de clonagem (Chatterbox, venv próprio): porta local na faixa do CenaForge.
|
||
clone_port: int = 4511
|
||
applio_dir: Path = VOICE_ROOT / "vendor" / "applio"
|
||
# auto = CUDA quando houver GPU NVIDIA utilizável; senão CPU. Vale para Whisper e RVC.
|
||
device: str = "auto"
|
||
# Vozes adicionadas pelo painel (fora do models.lock.json; o sha256 é gravado na hora de adicionar).
|
||
user_catalog_path: Path | None = None
|
||
# Transcrição (faster-whisper). Fila própria: STT não toma a vaga do TTS.
|
||
enable_stt: bool = False
|
||
stt_model: str = "small"
|
||
stt_compute_type: str = "auto"
|
||
stt_threads: int = 2
|
||
stt_beam_size: int = 1
|
||
stt_vad: bool = True
|
||
stt_max_bytes: int = 256 * 1024 * 1024
|
||
# Episódio inteiro: até 30 min. small int8 em CPU ≈ 0,25 s de CPU por 1 s de fala (≈ 8 min para 30 min).
|
||
stt_max_audio_s: float = 1800.0
|
||
stt_max_concurrency: int = 1
|
||
stt_max_queue_per_key: int = 4
|
||
# O job é assíncrono (o POST espera só stt_sync_wait_s), então a espera na fila não conta no timeout HTTP.
|
||
stt_queue_timeout_s: float = 1200.0
|
||
stt_timeout_s: float = 600.0
|
||
stt_sync_wait_s: float = 10.0
|
||
stt_job_ttl_s: int = 3600
|
||
stt_max_chars: int = 200_000
|
||
|
||
def timeout_warnings(self) -> list[str]:
|
||
"""Relações de timeout que, se não valerem, deixam uma chave levar `queue_timeout` por trabalho da outra."""
|
||
warnings = []
|
||
pairs = (
|
||
("VOICE_QUEUE_TIMEOUT_S", self.queue_timeout_s, "VOICE_SYNTH_TIMEOUT_S", self.synth_timeout_s),
|
||
("VOICE_STT_QUEUE_TIMEOUT_S", self.stt_queue_timeout_s, "VOICE_STT_TIMEOUT_S", self.stt_timeout_s),
|
||
)
|
||
for queue_name, queue_s, run_name, run_s in pairs:
|
||
if queue_s < QUEUE_TO_RUN_RATIO * run_s:
|
||
warnings.append(
|
||
f"{queue_name}={queue_s:g} abaixo de {QUEUE_TO_RUN_RATIO:g}x {run_name}={run_s:g}: "
|
||
"uma chave pode levar queue_timeout atrás de trabalho longo de outra"
|
||
)
|
||
if self.queue_timeout_s + self.synth_timeout_s >= BACKEND_CLIENT_TIMEOUT_S:
|
||
warnings.append(
|
||
f"VOICE_QUEUE_TIMEOUT_S + VOICE_SYNTH_TIMEOUT_S = {self.queue_timeout_s + self.synth_timeout_s:g} s "
|
||
f"não cabe no timeout do backend ({BACKEND_CLIENT_TIMEOUT_S:g} s): ele desiste antes da resposta"
|
||
)
|
||
return warnings
|
||
|
||
@staticmethod
|
||
def retired_vars_in_env() -> list[tuple[str, str]]:
|
||
"""(variável antiga, substituta) para cada variável aposentada ainda presente no ambiente."""
|
||
return [(old, new) for old, new in RETIRED_VARS.items() if os.environ.get(old, "") != ""]
|
||
|
||
@staticmethod
|
||
def from_env() -> "Settings":
|
||
load_dotenv(VOICE_ROOT / ".env")
|
||
key = os.environ.get("VOICE_SERVICE_KEY", "")
|
||
if len(key) < MIN_KEY_LENGTH:
|
||
raise ConfigError(
|
||
f"VOICE_SERVICE_KEY ausente ou curta (mínimo {MIN_KEY_LENGTH} caracteres); rode o setup.bat"
|
||
)
|
||
root = VOICE_ROOT
|
||
data = PROJECT_ROOT / "data" / "voice"
|
||
return Settings(
|
||
service_key=key,
|
||
models_dir=_path("VOICE_MODELS_DIR", data / "models"),
|
||
data_dir=_path("VOICE_DATA_DIR", data / "state"),
|
||
catalog_path=_path("VOICE_CATALOG", root / "voices" / "catalog.json"),
|
||
lock_path=_path("VOICE_MODELS_LOCK", root / "models.lock.json"),
|
||
user_catalog_path=_path("VOICE_USER_CATALOG", data / "user-voices.json"),
|
||
max_concurrency=_int("VOICE_MAX_CONCURRENCY", 1),
|
||
max_queue_per_key=_int("VOICE_MAX_QUEUE_PER_KEY", 8, minimum=0),
|
||
queue_timeout_s=_float("VOICE_QUEUE_TIMEOUT_S", 180.0),
|
||
synth_timeout_s=_float("VOICE_SYNTH_TIMEOUT_S", 90.0),
|
||
max_text_chars=_int("VOICE_MAX_TEXT_CHARS", 2000),
|
||
max_audio_s=_float("VOICE_MAX_AUDIO_S", 120.0),
|
||
cache_max_mb=_int("VOICE_CACHE_MAX_MB", 512),
|
||
idempotency_ttl_h=_int("VOICE_IDEMPOTENCY_TTL_H", 72),
|
||
onnx_threads=_int("VOICE_ONNX_THREADS", 2),
|
||
opus_bitrate=_int("VOICE_OPUS_BITRATE", 48000, minimum=6000),
|
||
verify_models=os.environ.get("VOICE_VERIFY_MODELS", "1") != "0",
|
||
enable_rvc=os.environ.get("VOICE_ENABLE_RVC", "0") == "1",
|
||
azure_key=os.environ.get("VOICE_AZURE_KEY", "").strip(),
|
||
azure_region=_azure_region(),
|
||
clone_port=_clone_port(),
|
||
applio_dir=_path("VOICE_APPLIO_DIR", root / "vendor" / "applio"),
|
||
device=_choice("VOICE_DEVICE", "auto", DEVICES),
|
||
enable_stt=os.environ.get("VOICE_ENABLE_STT", "1") == "1",
|
||
stt_model=_choice("VOICE_STT_MODEL", "small", STT_MODELS),
|
||
stt_compute_type=_choice(
|
||
"VOICE_STT_COMPUTE_TYPE", "auto", ("auto", "int8", "int8_float32", "int8_float16", "float16", "float32")
|
||
),
|
||
stt_threads=_int("VOICE_STT_THREADS", 2),
|
||
stt_beam_size=_int("VOICE_STT_BEAM_SIZE", 1),
|
||
stt_vad=os.environ.get("VOICE_STT_VAD", "1") != "0",
|
||
stt_max_bytes=_int("VOICE_STT_MAX_BYTES", 256 * 1024 * 1024, minimum=1024),
|
||
stt_max_audio_s=_float("VOICE_STT_MAX_AUDIO_S", 1800.0),
|
||
stt_max_concurrency=_int("VOICE_STT_MAX_CONCURRENCY", 1),
|
||
stt_max_queue_per_key=_int("VOICE_STT_MAX_QUEUE_PER_KEY", 4, minimum=0),
|
||
stt_queue_timeout_s=_float("VOICE_STT_QUEUE_TIMEOUT_S", 1200.0),
|
||
stt_timeout_s=_float("VOICE_STT_TIMEOUT_S", 600.0),
|
||
stt_sync_wait_s=_float("VOICE_STT_SYNC_WAIT_S", 10.0, minimum=0.0),
|
||
stt_job_ttl_s=_int("VOICE_STT_JOB_TTL_S", 3600, minimum=60),
|
||
)
|