primocode 8.42.2 → 9.1.0

package/studio/narrar.py

@@ -0,0 +1,274 @@
+#!/usr/bin/env python3
+"""narrar.py — a narração, em Python, sem servidor.
+
+    "Narração: gerar em Python, com biblioteca de TTS instalada no projeto. A
+     IA escolhe a voz e o estilo da narração."
+
+── POR QUE UM SCRIPT, E NÃO UM SERVIDOR ─────────────────────────────────────
+O Studio antigo subia um servidor Python em localhost:7777 e falava com ele
+por HTTP — inclusive para gerar narração. Aquilo existia porque havia uma
+interface web para servir. A interface morreu; o servidor não tem mais razão
+de ser, e com ele some uma classe inteira de defeito ("o estúdio não está
+rodando", porta ocupada, processo zumbi entre sessões).
+
+Aqui é um comando: entra texto, sai um mp3 e os tempos de cada fala.
+
+── OS TEMPOS SÃO MEDIDOS, NÃO ESTIMADOS ─────────────────────────────────────
+O edge-tts escreve as legendas junto com o áudio (`--write-media` +
+`--write-subtitles`). Delas sai o instante exato de cada frase.
+
+Isso é o que faz a cena caber na fala. Estimar duração por número de palavras
+erra em segundos, e o erro aparece como imagem trocando antes de a frase
+acabar — o defeito de vídeo automático mais fácil de reconhecer.
+
+── A CORRENTE ───────────────────────────────────────────────────────────────
+1. ELEVENLABS  se houver chave com crédito (melhor entonação, custa).
+2. EDGE TTS    neural, grátis, sem chave, sem conta.   ← o padrão
+3. diz que não deu, com o comando de instalar.
+
+Nunca uma voz de robô como "reserva": entregar um vídeo com voz dos anos 90
+é pior que entregar sem narração e dizer o que falta.
+
+Uso:
+    python3 narrar.py falar --texto "..." --saida narracao.mp3 [--voz antonio]
+                           [--ritmo -8%] [--tom +2Hz]
+    python3 narrar.py vozes
+"""
+
+import argparse
+import json
+import os
+import re
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+AQUI = Path(__file__).resolve().parent
+sys.path.insert(0, str(AQUI))
+
+# ── catálogo ────────────────────────────────────────────────────────────────
+# As vozes neurais de português do Brasil que existem no serviço da Microsoft.
+# Não há por que inventar mais: são estas três, e o `estilo` é o que a IA
+# escolhe para dar registro diferente à mesma voz.
+VOZES = [
+    {"id": "antonio", "voz": "pt-BR-AntonioNeural", "nome": "Antonio",
+     "genero": "masculina", "serve": "locução, abertura, institucional", "padrao": True},
+    {"id": "francisca", "voz": "pt-BR-FranciscaNeural", "nome": "Francisca",
+     "genero": "feminina", "serve": "conversa, explicação, tutorial"},
+    {"id": "thalita", "voz": "pt-BR-ThalitaMultilingualNeural", "nome": "Thalita",
+     "genero": "feminina", "serve": "jovem, anúncio, redes sociais"},
+]
+
+# O "estilo" não existe como parâmetro no edge-tts: ele é ritmo + tom. Estes
+# quatro cobrem o que se pede num vídeo, e são o ponto de partida — a IA pode
+# mandar ritmo e tom na mão quando quiser outra coisa.
+ESTILOS = {
+    "normal":    {"ritmo": "+0%",  "tom": "+0Hz"},
+    "anuncio":   {"ritmo": "+8%",  "tom": "+2Hz"},   # mais rápido e mais alto: energia
+    "calmo":     {"ritmo": "-8%",  "tom": "-2Hz"},   # mais devagar e mais grave: explicação
+    "dramatico": {"ritmo": "-14%", "tom": "-4Hz"},   # pausa e peso
+}
+
+
+def voz_de(apelido):
+    a = (apelido or "").strip().lower()
+    for v in VOZES:
+        if a in (v["id"], v["voz"].lower(), v["nome"].lower()):
+            return v
+    return VOZES[0]
+
+
+def tempo_vtt(marca):
+    """"00:00:03.480" → 3.48"""
+    h, m, s = marca.split(":")
+    return int(h) * 3600 + int(m) * 60 + float(s.replace(",", "."))
+
+
+def ler_legendas(caminho):
+    """As falas com início e fim, lidas do VTT que o edge-tts escreveu."""
+    falas = []
+    try:
+        bruto = Path(caminho).read_text(encoding="utf-8")
+    except OSError:
+        return falas
+    bloco = None
+    for linha in bruto.splitlines():
+        linha = linha.strip()
+        if "-->" in linha:
+            de, ate = [p.strip() for p in linha.split("-->")[:2]]
+            bloco = {"de": tempo_vtt(de), "ate": tempo_vtt(ate.split(" ")[0]), "texto": ""}
+        elif bloco is not None and linha:
+            bloco["texto"] = (bloco["texto"] + " " + linha).strip()
+        elif bloco is not None and not linha:
+            if bloco["texto"]:
+                falas.append(bloco)
+            bloco = None
+    if bloco and bloco["texto"]:
+        falas.append(bloco)
+    return falas
+
+
+def edge_disponivel():
+    try:
+        subprocess.run([sys.executable, "-m", "edge_tts", "--help"],
+                       capture_output=True, timeout=25, check=True)
+        return True
+    except Exception:
+        return False
+
+
+# Por que uma única tentativa de pip não serve — e falha CALADA.
+#
+# Em Debian e Ubuntu, e no Python do Homebrew, o `pip install` no Python do
+# sistema é recusado de saída: "externally-managed-environment" (PEP 668). Em
+# máquina sem pip, o `-m pip` nem existe. Uma tentativa só, com a saída jogada
+# fora, é exatamente a falha que ninguém vê: a instalação "não deu erro", o
+# edge-tts continua ausente, e a narração cai calada na voz de reserva — o
+# vídeo sai com outra voz e ninguém sabe por quê.
+#
+# Então são várias tentativas, em ordem da menos invasiva para a mais, e o
+# erro da última fica guardado para a resposta poder contar o que houve.
+ESTRATEGIAS = [
+    ["-m", "pip", "install", "--user", "--quiet", "edge-tts"],
+    ["-m", "pip", "install", "--user", "--quiet", "--break-system-packages", "edge-tts"],
+    ["-m", "pip", "install", "--quiet", "edge-tts"],
+    ["-m", "pip", "install", "--quiet", "--break-system-packages", "edge-tts"],
+]
+
+ultimo_erro_pip = ""
+
+
+def instalar_edge():
+    """Traz o edge-tts com pip. Uma vez, e o usuário vê acontecer."""
+    global ultimo_erro_pip
+
+    # Sem pip, primeiro o ensurepip — é o que o python.org e a Apple trazem
+    # justamente para este caso.
+    try:
+        r = subprocess.run([sys.executable, "-m", "pip", "--version"],
+                           capture_output=True, timeout=30)
+        if r.returncode != 0:
+            subprocess.run([sys.executable, "-m", "ensurepip", "--default-pip"],
+                           capture_output=True, timeout=120)
+    except Exception as e:
+        ultimo_erro_pip = str(e)
+
+    for args in ESTRATEGIAS:
+        try:
+            r = subprocess.run([sys.executable] + args, capture_output=True, timeout=240)
+            if r.returncode == 0 and edge_disponivel():
+                return True
+            saida = (r.stderr or b"").decode("utf-8", "replace").strip()
+            if saida:
+                ultimo_erro_pip = saida.splitlines()[-1][:300]
+        except Exception as e:
+            ultimo_erro_pip = str(e)[:300]
+    return False
+
+
+def falar_edge(texto, saida, voz, ritmo, tom):
+    with tempfile.TemporaryDirectory() as tmp:
+        vtt = str(Path(tmp) / "legenda.vtt")
+        cmd = [
+            sys.executable, "-m", "edge_tts",
+            "--voice", voz,
+            "--text", texto,
+            "--write-media", str(saida),
+            "--write-subtitles", vtt,
+        ]
+        if ritmo and ritmo != "+0%":
+            cmd += ["--rate", ritmo]
+        if tom and tom != "+0Hz":
+            cmd += ["--pitch", tom]
+
+        r = subprocess.run(cmd, capture_output=True, timeout=300)
+        if r.returncode != 0 or not Path(saida).exists():
+            return {"ok": False, "error": (r.stderr or b"").decode("utf-8", "ignore")[-400:]}
+
+        falas = ler_legendas(vtt)
+        return {
+            "ok": True,
+            "arquivo": str(saida),
+            "motor": "edge",
+            "voz": voz,
+            "segundos": round(falas[-1]["ate"], 3) if falas else None,
+            "falas": [{"de": round(f["de"], 3), "ate": round(f["ate"], 3), "texto": f["texto"]}
+                      for f in falas],
+        }
+
+
+def falar_elevenlabs(texto, saida, voz):
+    """Só quando há chave. Sem ela, nem se tenta — e não é erro."""
+    chave = os.environ.get("ELEVENLABS_API_KEY", "").strip()
+    if not chave:
+        return None
+    try:
+        sys.path.insert(0, str(AQUI))
+        import elevenlabs  # o módulo que já existia no Studio
+        r = elevenlabs.falar(texto, str(saida), voz=voz, chave=chave)
+        if r and r.get("ok"):
+            r["motor"] = "elevenlabs"
+            return r
+    except Exception:
+        pass
+    return None
+
+
+def comando_falar(args):
+    texto = args.texto
+    if args.arquivo:
+        texto = Path(args.arquivo).read_text(encoding="utf-8")
+    texto = re.sub(r"\s+", " ", (texto or "")).strip()
+    if not texto:
+        return {"ok": False, "error": "não há texto para narrar"}
+
+    v = voz_de(args.voz)
+    estilo = ESTILOS.get((args.estilo or "normal").lower(), ESTILOS["normal"])
+    ritmo = args.ritmo or estilo["ritmo"]
+    tom = args.tom or estilo["tom"]
+
+    premium = falar_elevenlabs(texto, args.saida, v["id"])
+    if premium:
+        return premium
+
+    if not edge_disponivel() and not instalar_edge():
+        return {
+            "ok": False,
+            "error": "a narração precisa do pacote edge-tts, e não deu para instalá-lo aqui.",
+            "comoResolver": f"{sys.executable} -m pip install edge-tts"
+                            + (" (no Debian/Ubuntu ou no Homebrew, acrescente --break-system-packages)"
+                               if "externally-managed" in ultimo_erro_pip else ""),
+            "erroDoPip": ultimo_erro_pip or None,
+        }
+
+    return falar_edge(texto, args.saida, v["voz"], ritmo, tom)
+
+
+def main():
+    p = argparse.ArgumentParser(description="Narração do PrimoCode Studio")
+    sub = p.add_subparsers(dest="comando", required=True)
+
+    f = sub.add_parser("falar")
+    f.add_argument("--texto", default="")
+    f.add_argument("--arquivo", default="")
+    f.add_argument("--saida", required=True)
+    f.add_argument("--voz", default="antonio")
+    f.add_argument("--estilo", default="normal")
+    f.add_argument("--ritmo", default="")
+    f.add_argument("--tom", default="")
+
+    sub.add_parser("vozes")
+
+    args = p.parse_args()
+    if args.comando == "vozes":
+        saida = {"ok": True, "vozes": VOZES, "estilos": list(ESTILOS.keys())}
+    else:
+        saida = comando_falar(args)
+
+    print(json.dumps(saida, ensure_ascii=False))
+    sys.exit(0 if saida.get("ok") else 1)
+
+
+if __name__ == "__main__":
+    main()

package/studio/pessoa.py

@@ -0,0 +1,199 @@
+#!/usr/bin/env python3
+"""pessoa.py — tirar você do fundo do seu próprio vídeo.
+
+    "Recorte de pessoa: segmentar meu rosto/corpo e trocar o fundo por uma
+     imagem relacionada ao que estou falando (ex.: falando sobre o olho →
+     imagem do olho no fundo)."
+
+── POR QUE ISTO NÃO É FEITO COM ffmpeg ──────────────────────────────────────
+O ffmpeg sabe fazer chroma key: tirar um fundo VERDE. Ele não sabe olhar um
+quadro e dizer onde termina a pessoa e começa a parede — isso é trabalho de
+modelo de visão, quadro a quadro.
+
+O MediaPipe faz exatamente isso, roda no computador da pessoa, é grátis e não
+precisa de chave. O custo é o download do modelo na primeira vez.
+
+── O QUE SAI DAQUI ──────────────────────────────────────────────────────────
+Um .webm com CANAL ALFA: a pessoa recortada, e transparência no lugar do
+fundo. Ele não é o resultado final — é a peça que o `video.sobreporAlfa`
+costura sobre a imagem escolhida, ou que entra como elemento de vídeo numa
+cena com qualquer coisa atrás.
+
+Separar assim é de propósito: o recorte é caro (segundos por segundo de
+vídeo) e o fundo muda de ideia. Recortar uma vez e testar cinco fundos custa
+um recorte; recortar junto com o fundo custa cinco.
+
+── A BORDA É O QUE DENUNCIA ─────────────────────────────────────────────────
+Recorte automático erra na borda do cabelo, e o erro aparece como um contorno
+duro, tipo adesivo. Duas defesas: suavizar a máscara (desfoque leve) e
+encolhê-la um pouco, para o corte cair um fio DENTRO da pessoa em vez de
+pegar um halo da parede.
+
+Uso:
+    python3 pessoa.py recortar --entrada gravacao.mp4 --saida pessoa.webm
+    python3 pessoa.py conferir
+"""
+
+import argparse
+import json
+import shutil
+import os
+import subprocess
+import sys
+
+
+def achar_ffmpeg():
+    """Onde está o ffmpeg — pelo PATH, e nos lugares onde ele costuma cair.
+
+    O PATH de um processo aberto pela interface gráfica não é o PATH do
+    terminal: no macOS um app aberto pelo ícone não enxerga /opt/homebrew/bin,
+    onde o Homebrew instala. Procurar nos lugares conhecidos evita um "não
+    achei" para quem tem o programa instalado.
+    """
+    achado = shutil.which("ffmpeg")
+    if achado:
+        return achado
+    for c in ("/opt/homebrew/bin/ffmpeg", "/usr/local/bin/ffmpeg", "/usr/bin/ffmpeg",
+              r"C:\Program Files\ffmpeg\bin\ffmpeg.exe"):
+        if os.path.exists(c):
+            return c
+    return None
+
+
+def faltando():
+    """O que precisa estar instalado, e não está."""
+    falta = []
+    for modulo, pacote in (("cv2", "opencv-python"), ("mediapipe", "mediapipe"), ("numpy", "numpy")):
+        try:
+            __import__(modulo)
+        except ImportError:
+            falta.append(pacote)
+    return falta
+
+
+def instalar(pacotes):
+    try:
+        subprocess.run([sys.executable, "-m", "pip", "install", "--quiet", *pacotes],
+                       capture_output=True, timeout=900, check=True)
+        return not faltando()
+    except Exception:
+        return False
+
+
+def recortar(entrada, saida, suavizar=7, encolher=2, limiar=0.6):
+    import cv2
+    import numpy as np
+    import mediapipe as mp
+
+    captura = cv2.VideoCapture(entrada)
+    if not captura.isOpened():
+        return {"ok": False, "error": f"não consegui abrir {entrada}"}
+
+    fps = captura.get(cv2.CAP_PROP_FPS) or 30
+    largura = int(captura.get(cv2.CAP_PROP_FRAME_WIDTH))
+    altura = int(captura.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    total = int(captura.get(cv2.CAP_PROP_FRAME_COUNT)) or 0
+
+    # VP9 num .webm é o formato de vídeo com transparência que o Chromium do
+    # Remotion abre — e é o Chromium dele que vai desenhar isto.
+    # O ffmpeg pelo nome cru estoura FileNotFoundError, e o que chega ao
+    # usuário é o traceback do Python — que não diz o que instalar. Pior: aqui
+    # o vídeo já foi ABERTO e a segmentação está prestes a começar, então a
+    # falha aparece depois da espera, não antes dela.
+    binario = achar_ffmpeg()
+    if not binario:
+        captura.release()
+        return {"ok": False,
+                "error": "o recorte de pessoa precisa do ffmpeg, e não achei nenhum nesta máquina.",
+                "comoResolver": "macOS: brew install ffmpeg · Linux: sudo apt install ffmpeg · "
+                                "Windows: winget install ffmpeg"}
+
+    escritor = subprocess.Popen(
+        [binario, "-hide_banner", "-loglevel", "error", "-y",
+         "-f", "rawvideo", "-pix_fmt", "bgra",
+         "-s", f"{largura}x{altura}", "-r", str(fps), "-i", "-",
+         "-c:v", "libvpx-vp9", "-pix_fmt", "yuva420p", "-b:v", "3M",
+         "-auto-alt-ref", "0", saida],
+        stdin=subprocess.PIPE, stderr=subprocess.PIPE)
+
+    segmentador = mp.solutions.selfie_segmentation.SelfieSegmentation(model_selection=1)
+    nucleo = np.ones((3, 3), np.uint8)
+    feitos = 0
+
+    try:
+        while True:
+            ok, quadro = captura.read()
+            if not ok:
+                break
+            resultado = segmentador.process(cv2.cvtColor(quadro, cv2.COLOR_BGR2RGB))
+            mascara = (resultado.segmentation_mask > limiar).astype(np.uint8) * 255
+
+            # Encolher: o corte cai um fio DENTRO da pessoa, em vez de levar
+            # um halo da parede junto — é o halo que faz parecer adesivo.
+            if encolher > 0:
+                mascara = cv2.erode(mascara, nucleo, iterations=int(encolher))
+            # Suavizar: borda dura no cabelo é o segundo sinal de recorte
+            # automático. Ímpar porque o desfoque gaussiano exige.
+            if suavizar > 0:
+                k = int(suavizar) | 1
+                mascara = cv2.GaussianBlur(mascara, (k, k), 0)
+
+            bgra = cv2.cvtColor(quadro, cv2.COLOR_BGR2BGRA)
+            bgra[:, :, 3] = mascara
+            escritor.stdin.write(bgra.tobytes())
+            feitos += 1
+    finally:
+        try:
+            escritor.stdin.close()
+        except Exception:
+            pass
+        captura.release()
+        segmentador.close()
+
+    escritor.wait()
+    if escritor.returncode != 0:
+        erro = (escritor.stderr.read() or b"").decode("utf-8", "ignore")[-400:]
+        return {"ok": False, "error": f"o ffmpeg recusou o recorte: {erro}"}
+
+    return {"ok": True, "arquivo": saida, "quadros": feitos,
+            "segundos": round(feitos / fps, 2) if fps else None,
+            "largura": largura, "altura": altura, "fps": round(fps, 2)}
+
+
+def main():
+    p = argparse.ArgumentParser(description="Recorte de pessoa do PrimoCode Studio")
+    sub = p.add_subparsers(dest="comando", required=True)
+    sub.add_parser("conferir")
+    r = sub.add_parser("recortar")
+    r.add_argument("--entrada", required=True)
+    r.add_argument("--saida", required=True)
+    r.add_argument("--suavizar", type=int, default=7)
+    r.add_argument("--encolher", type=int, default=2)
+    r.add_argument("--limiar", type=float, default=0.6)
+    args = p.parse_args()
+
+    falta = faltando()
+
+    if args.comando == "conferir":
+        saida = {"ok": not falta, "falta": falta,
+                 "comoResolver": f"{sys.executable} -m pip install " + " ".join(falta) if falta else None}
+    else:
+        if falta:
+            # A instalação é pesada (o MediaPipe passa de 100 MB) e demora.
+            # Tentar em silêncio seria uma tarefa parada sem explicação; por
+            # isso o aviso sai ANTES, na saída de erro, que o agente mostra.
+            print(f"instalando {', '.join(falta)} (uma vez, alguns minutos)…", file=sys.stderr)
+            if not instalar(falta):
+                saida = {"ok": False,
+                         "error": "o recorte de pessoa precisa do MediaPipe, e não deu para instalá-lo.",
+                         "comoResolver": f"{sys.executable} -m pip install " + " ".join(falta)}
+                print(json.dumps(saida, ensure_ascii=False))
+                sys.exit(1)
+        saida = recortar(args.entrada, args.saida, args.suavizar, args.encolher, args.limiar)
+
+    print(json.dumps(saida, ensure_ascii=False))
+    sys.exit(0 if saida.get("ok") else 1)
+
+
+if __name__ == "__main__":
+    main()