"""Processo de clonagem de voz do CenaForge (Chatterbox Multilingual, licença MIT). Roda num venv próprio (voice/.venv-clone): o Chatterbox fixa torch 2.6, numpy < 2 e um transformers diferente do serviço de voz. O serviço de voz (porta 4510) chama este processo pela rede local. Contrato (só 127.0.0.1, cabeçalho X-Service-Key = VOICE_SERVICE_KEY): - GET /health → {"status": "loading" | "ok" | "error", "device", "error"?} - POST /synthesize JSON {text, reference, language, exaggeration, cfgWeight} → audio/wav (24 kHz, mono, PCM 16) `reference` precisa estar dentro de /clone/. Pesos: baixados do Hugging Face (ResembleAI/chatterbox) na primeira subida, para data/voice/models/clone-hf. Todo áudio gerado leva a marca d'água inaudível do Chatterbox (PerTh). """ from __future__ import annotations import hmac import io import json import logging import os import re import sys import threading import time from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer from pathlib import Path VOICE_ROOT = Path(__file__).resolve().parents[1] PROJECT_ROOT = VOICE_ROOT.parent MAX_TEXT_CHARS = 2000 MAX_CHUNK_CHARS = 280 # o Chatterbox perde qualidade em trechos longos: gera por frase e junta PAUSE_S = 0.18 logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s", stream=sys.stdout) log = logging.getLogger("cenaforge_clone") def _read_env() -> dict[str, str]: """voice/.env (o dev.ts já repassa, mas rodar à mão também funciona).""" values: dict[str, str] = {} env_file = VOICE_ROOT / ".env" if env_file.is_file(): for line in env_file.read_text(encoding="utf-8").splitlines(): if "=" in line and not line.lstrip().startswith("#"): name, value = line.split("=", 1) values[name.strip()] = value.strip() return {**values, **{k: v for k, v in os.environ.items() if k.startswith("VOICE_")}} ENV = _read_env() KEY = ENV.get("VOICE_SERVICE_KEY", "") PORT = int(ENV.get("VOICE_CLONE_PORT", "4511")) _models = ENV.get("VOICE_MODELS_DIR", "") MODELS_DIR = (PROJECT_ROOT / _models).resolve() if _models and not Path(_models).is_absolute() else Path( _models or PROJECT_ROOT / "data" / "voice" / "models" ).resolve() CLONE_DIR = (MODELS_DIR / "clone").resolve() # Cache do Hugging Face dentro de data/ (não no perfil do usuário): apagar data/voice/models remove tudo. os.environ.setdefault("HF_HOME", str(MODELS_DIR / "clone-hf")) # Windows sem modo desenvolvedor não cria symlink: o cache funciona copiando, e o aviso só polui o terminal. os.environ.setdefault("HF_HUB_DISABLE_SYMLINKS_WARNING", "1") # O download pelo protocolo Xet travou nesta máquina (256 MB em 9 min, arquivo de 2 GB parado); HTTP comum baixou tudo. os.environ.setdefault("HF_HUB_DISABLE_XET", "1") # Uma linha por arquivo baixado do Hugging Face enche o terminal do pnpm dev. logging.getLogger("httpx").setLevel(logging.WARNING) class Engine: """Carrega o modelo uma vez (em segundo plano) e serializa as gerações (uma placa, um modelo).""" def __init__(self) -> None: self.status = "loading" self.error: str | None = None self.device = "cpu" self.model = None self._lock = threading.Lock() self._conds_key: tuple | None = None def load(self) -> None: try: import torch from chatterbox.mtl_tts import ChatterboxMultilingualTTS wanted = ENV.get("VOICE_DEVICE", "auto") self.device = "cuda" if wanted != "cpu" and torch.cuda.is_available() else "cpu" started = time.monotonic() self.model = ChatterboxMultilingualTTS.from_pretrained(device=torch.device(self.device)) self.status = "ok" log.info("clonagem pronta em %s (%.0f s)", self.device, time.monotonic() - started) except Exception as exc: # noqa: BLE001 - qualquer falha de carga vira estado "error" no /health self.status, self.error = "error", f"{type(exc).__name__}: {exc}" log.exception("falha ao carregar o Chatterbox") def synthesize(self, text: str, reference: Path, language: str, exaggeration: float, cfg_weight: float) -> bytes: import numpy as np import soundfile with self._lock: model = self.model stamp = reference.stat() key = (str(reference), stamp.st_mtime_ns, stamp.st_size, exaggeration) if key != self._conds_key: # Condicionamento da voz (timbre da referência): caro, então só refaz quando muda. model.prepare_conditionals(str(reference), exaggeration=exaggeration) self._conds_key = key pieces = [] silence = np.zeros(int(model.sr * PAUSE_S), dtype=np.float32) for chunk in split_text(text): wav = model.generate(chunk, language_id=language, exaggeration=exaggeration, cfg_weight=cfg_weight) pieces.extend([wav.squeeze(0).detach().cpu().numpy().astype(np.float32), silence]) audio = np.concatenate(pieces[:-1]) if pieces else silence buffer = io.BytesIO() soundfile.write(buffer, np.clip(audio, -1.0, 1.0), model.sr, format="WAV", subtype="PCM_16") return buffer.getvalue() def split_text(text: str) -> list[str]: """Quebra em frases e junta as curtas até ~280 caracteres (frase longa demais é cortada nas vírgulas).""" sentences = [s.strip() for s in re.split(r"(?<=[.!?…])\s+", text.strip()) if s.strip()] chunks: list[str] = [] for sentence in sentences: parts = [sentence] if len(sentence) <= MAX_CHUNK_CHARS else [p.strip() for p in re.split(r"(?<=[,;:])\s+", sentence)] for part in parts: if chunks and len(chunks[-1]) + 1 + len(part) <= MAX_CHUNK_CHARS: chunks[-1] = f"{chunks[-1]} {part}" else: chunks.append(part[:MAX_CHUNK_CHARS * 2]) return chunks ENGINE = Engine() class Handler(BaseHTTPRequestHandler): server_version = "cenaforge-clone" def log_message(self, format: str, *args) -> None: # noqa: A002 - assinatura da stdlib return # sem log de acesso (o texto do usuário não vai para o terminal) def _send(self, status: int, body: bytes, content_type: str = "application/json") -> None: self.send_response(status) self.send_header("Content-Type", content_type) self.send_header("Content-Length", str(len(body))) self.send_header("Cache-Control", "no-store") self.end_headers() self.wfile.write(body) def _error(self, status: int, message: str) -> None: self._send(status, json.dumps({"error": message}, ensure_ascii=False).encode("utf-8")) def _authorized(self) -> bool: given = self.headers.get("X-Service-Key", "") return bool(KEY) and hmac.compare_digest(given.encode("utf-8"), KEY.encode("utf-8")) def do_GET(self) -> None: # noqa: N802 - nome da stdlib if self.path != "/health": return self._error(404, "rota desconhecida") payload = {"status": ENGINE.status, "device": ENGINE.device} if ENGINE.error: payload["error"] = ENGINE.error self._send(200, json.dumps(payload).encode("utf-8")) def do_POST(self) -> None: # noqa: N802 - nome da stdlib if self.path != "/synthesize": return self._error(404, "rota desconhecida") if not self._authorized(): return self._error(401, "chave ausente ou inválida") if ENGINE.status != "ok": return self._error(503, f"modelo ainda {'carregando' if ENGINE.status == 'loading' else 'com erro'}") try: length = int(self.headers.get("Content-Length", "0")) if not 0 < length <= 64 * 1024: raise ValueError("corpo vazio ou grande demais") body = json.loads(self.rfile.read(length)) text = str(body["text"]).strip() if not text or len(text) > MAX_TEXT_CHARS: raise ValueError(f"texto vazio ou acima de {MAX_TEXT_CHARS} caracteres") reference = Path(str(body["reference"])).resolve() if CLONE_DIR not in reference.parents or not reference.is_file(): raise ValueError("áudio de referência fora de data/voice/models/clone ou ausente") language = str(body.get("language", "pt"))[:5] exaggeration = min(1.5, max(0.25, float(body.get("exaggeration", 0.5)))) cfg_weight = min(1.0, max(0.0, float(body.get("cfgWeight", 0.5)))) except (ValueError, KeyError, TypeError, json.JSONDecodeError) as exc: return self._error(400, str(exc)) try: wav = ENGINE.synthesize(text, reference, language, exaggeration, cfg_weight) except Exception as exc: # noqa: BLE001 - falha do modelo vira 500 com o tipo do erro log.exception("falha ao gerar a voz clonada") return self._error(500, f"{type(exc).__name__}: {exc}") self._send(200, wav, "audio/wav") def main() -> None: if len(KEY) < 32: log.error("VOICE_SERVICE_KEY ausente: rode o setup.bat") sys.exit(1) if not 4500 <= PORT <= 4599: log.error("VOICE_CLONE_PORT=%s fora da faixa 4500–4599 do CenaForge", PORT) sys.exit(1) threading.Thread(target=ENGINE.load, name="load-model", daemon=True).start() server = ThreadingHTTPServer(("127.0.0.1", PORT), Handler) log.info("clonagem ouvindo em 127.0.0.1:%d (modelo carregando…)", PORT) try: server.serve_forever() except KeyboardInterrupt: pass if __name__ == "__main__": main()