Files
CenaForge/clipper/tests/test_duration_banner_fonts.py
MateuusandClaude Opus 5.5 f165659e4e Painel: ordenar fila de cortes, horário específico ao publicar e capas preservadas
Clipador (fila de cortes)
- Seletor "Ordenar": mais novos, mais antigos, maior/menor nota da IA, sinal
  mais forte e mais longos; a escolha fica lembrada no navegador.
- A fila abre filtrada pela sessão que está gravando.
- Gancho automático logo abaixo da câmera e legenda desviada enquanto o gancho
  a cobriria; posição do gancho editável no painel.

Publicação
- "Publicar este corte" ganha "Horário específico": um dia e hora para todas
  as redes ou um diferente por rede (timing "at" + scheduledAt por rede na rota
  POST /api/publishing/clips/[id]), com validação e testes.
- Capa do vídeo publicado copiada para output/publishing/covers/: apagar a
  sessão no Clipador não quebra mais a miniatura do dashboard; jobs antigos
  migram no ciclo de sincronização.
- Dashboard só usa capa que existe no disco; corrige a regex do número do
  episódio (link do episódio).
- Canais de publicação: seletor compacto de canais e detalhe reorganizado.
- Publicador: confirmação pela página pública quando o YouTube Studio fica com
  a caixa de envio aberta; estatísticas por rede.

Skill cenaforge 1.44.0 com as regras e a armadilha das capas.

Testes: painel 68/68, Clipador 279, Publicador 84.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-17 19:54:13 -03:00

312 lines
18 KiB
Python
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""Pedidos do dono de 17/11/2026: duração mínima de verdade (mínimo + 1 s em todo corte automático), gancho em tarja
animada e fontes empacotadas para escolher."""
import hashlib
import json
import re
import shutil
import subprocess
from pathlib import Path
import pytest
from app import editor, editor_render, layout
from app.config import REPO_ROOT
from app.judge import _clean
from app.scoring import ChatMessage, Params, Word, find_moments, fit_length, fit_window
from .test_editor import KEY, api, make_project, validate # noqa: F401 - api é fixture
from .test_scoring import burst, calm_chat
from .test_sources_and_api import env, seed_session # noqa: F401
FFMPEG, FFPROBE = shutil.which("ffmpeg"), shutil.which("ffprobe")
CFG = layout.merge()
TARGET = layout.min_target(CFG) # 60 + 1 + 0,1
EPS = 1e-6 # 61,1 em ponto flutuante
HORIZONTAL = {"format": {"aspect": "horizontal"}}
# ---------------------------------------------------------------- 1. duração mínima
def test_target_is_min_plus_one_second_and_never_above_max():
assert TARGET == 61.1
assert layout.min_target(layout.merge({"duration": {"minS": 89.5, "maxS": 90}})) == 90
def test_fit_window_grows_backwards_then_forwards_and_never_invents():
assert fit_window(100, 140, 0, 200, TARGET, 90) == (78.9, 140.0) # contexto antes
assert fit_window(5, 30, 0, 200, TARGET, 90) == (0.0, 61.1) # começo da gravação: cresce para a frente
assert fit_window(5, 30, 0, 40, TARGET, 90) == (0.0, 40.0) # gravação de 40 s: não inventa
assert fit_window(0, 200, 0, 300, TARGET, 90, keep="start") == (0.0, 90.0)
def test_candidate_from_heuristic_has_the_target_even_at_the_end_of_recording():
p = Params(min_s=TARGET, max_s=90.0)
chat = calm_chat(600) + burst(300, 8, 25, "KKKKKKKKK")
m = find_moments(600, chat, [], [], p)[0]
assert m.end_s - m.start_s >= TARGET - EPS
start, end = fit_length(580, 600, 595, p, 600) # pico no fim da gravação: recua o início
assert end - start >= TARGET - EPS and end <= 600
def test_judge_answer_capped_by_window_end_still_has_the_minimum():
# O juiz pôs o início tarde demais: o fim bate em `hi`; antes saía curto (end − start < mínimo).
v = _clean({"keep": True, "score": 8, "start_s": 1100, "end_s": 1200, "title": "t", "caption": "c", "reason": "r"},
1095, 1155, "m", lo=975, hi=1170, min_s=TARGET, max_s=90)
assert v.end_s == 1170 and v.end_s - v.start_s >= TARGET - EPS
def test_scan_moment_has_the_minimum(env): # noqa: F811
_client, engine = env
sid = seed_session(engine)
session = engine.db.get("SELECT * FROM sessions WHERE id = ?", sid)
ok = engine.intel._insert_scan_moment(session, {"start_s": 470, "end_s": 495, "score": 7, "title": "t", "reason": "r"},
300.0, 500.0, CFG["duration"], [])
clip = engine.db.get("SELECT start_s, end_s FROM clips WHERE session_id = ?", sid)
assert ok and clip["end_s"] - clip["start_s"] >= TARGET - EPS and clip["end_s"] <= 500
def _clip55():
"""Caso medido (corte 55 da sessão 3): juiz 7900–7960 (60 s) e analista com a ação em 7915 → saía 46,8 s."""
clip = {"session_id": 1, "start_s": 7900.0, "end_s": 7960.7, "peak_s": 7944.0, "title": "Pajé mão leve", "source": "chat"}
words = [Word(7880 + i * 0.9, 7880 + i * 0.9 + 0.5, f"p{i}") for i in range(100)]
return clip, {"action_start_s": 7915.0, "reaction_end_s": 7952.0, "hook": "Pajé mão leve"}, words
def test_auto_project_never_goes_below_the_minimum():
clip, analysis, words = _clip55()
p = editor.auto_project(clip, analysis, words, [-20.0] * 9000, 9000.0, CFG)
assert editor.output_duration(p["cuts"]) >= TARGET - EPS
# silêncios quietos longos: só sai o que não derruba o corte abaixo do mínimo
quiet = [-55.0] * 9000
sparse = [Word(7890 + i * 6, 7890 + i * 6 + 0.4, "x") for i in range(14)]
q = editor.auto_project({**clip, "peak_s": 7899.0}, None, sparse, quiet, 9000.0, CFG)
assert editor.output_duration(q["cuts"]) >= TARGET - EPS
# gravação curta demais: não inventa vídeo, registra o motivo
r = editor.auto_project({**clip, "start_s": 5.0, "end_s": 30.0, "peak_s": 20.0}, None, [], [], 40.0, CFG)
assert editor.output_duration(r["cuts"]) == 40.0 and any(s.startswith("curto:") for s in r["meta"]["steps"])
# "cortar agora" (manual) é livre
m = editor.auto_project({**clip, "source": "manual", "start_s": 7900.0, "end_s": 7930.0}, None, [], [], 9000.0, CFG)
assert editor.output_duration(m["cuts"]) == 30.0
def test_suggestion_respects_minimum_and_drops_removes_that_would_shrink_it():
s = editor.clean_suggestion({"start_s": 1100, "end_s": 1130, "remove": [{"start_s": 1110, "end_s": 1120, "why": "x"}],
"zooms": [], "hook": "h", "title": "t", "reason": "r"}, 1000, 1200, TARGET, 90)
assert s["end"] - s["start"] >= TARGET - EPS and s["remove"] == []
@pytest.mark.skipif(not (FFMPEG and FFPROBE), reason="FFmpeg não instalado")
def test_auto_clip_file_is_at_least_min_plus_one_second(tmp_path):
"""Medido no arquivo (ffprobe): o projeto da IA do caso do corte 55 sai com ≥ 61 s."""
seg = tmp_path / "seg.ts"
subprocess.run([FFMPEG, "-v", "error", "-f", "lavfi", "-i", "testsrc2=size=320x180:rate=30:duration=100", "-f", "lavfi",
"-i", "sine=frequency=440:duration=100", "-c:v", "libx264", "-preset", "ultrafast", "-g", "15",
"-c:a", "aac", "-shortest", str(seg)], check=True)
clip = {"session_id": 1, "start_s": 30.0, "end_s": 90.7, "peak_s": 74.0, "title": "Pajé mão leve", "source": "chat"}
analysis = {"action_start_s": 45.0, "reaction_end_s": 82.0, "hook": "Pajé mão leve"}
data = editor.auto_project(clip, analysis, [], [-20.0] * 100, 100.0, CFG)
p = validate(data, tmp_path, duration=100.0)
out = tmp_path / "auto.mp4"
editor_render.render_project(FFMPEG, FFPROBE, ["-c:v", "libx264", "-preset", "ultrafast"], [(seg, 0.0, 100.0)], p, CFG,
"twitch.tv/x", out, tmp_path)
duration = float(subprocess.run([FFPROBE, "-v", "error", "-show_entries", "format=duration", "-of", "csv=p=0", str(out)],
capture_output=True, text=True, check=True).stdout)
assert duration >= CFG["duration"]["minS"] + 1
# ---------------------------------------------------------------- 2. gancho em tarja
def _banner(**over):
o = {"id": "hook", "kind": "hook", "text": "Carregando o dilera no PvP do Rob Run!", "start": 0, "end": 3, "y": 0.2,
"size": 76, "style": "banner", "bg": "#00FF00", "color": "#FFFFFF", "font": layout.HOOK_FONT, "anim": "slide"}
o.update(over)
return o
def test_hook_config_validates_and_merges():
assert layout.DEFAULTS["hook"]["style"] == "banner" and layout.DEFAULTS["hook"]["anim"] == "slide"
assert layout.validate({"hook": {"style": "plain", "bg": "#123abc", "seconds": 2.5}})["hook"] == \
{"style": "plain", "bg": "#123ABC", "seconds": 2.5}
for bad in ({"style": "x"}, {"bg": "verde"}, {"font": "Comic Sans"}, {"anim": "spin"}, {"seconds": 20}):
with pytest.raises(layout.LayoutError):
layout.validate({"hook": bad})
def test_banner_overlay_validation_and_old_projects_untouched(tmp_path):
p = validate(make_project(overlays=[_banner()]), tmp_path)
o = p["overlays"][0]
assert (o["style"], o["bg"], o["font"], o["anim"]) == ("banner", "#00FF00", layout.HOOK_FONT, "slide")
old = validate(make_project(), tmp_path)["overlays"][0]
assert not {"style", "bg", "font"} & set(old) # projeto antigo: nenhum campo novo aparece
for bad in ({"style": "neon"}, {"font": "Comic Sans"}, {"bg": "verde"}, {"anim": "spin"}):
with pytest.raises(editor.EditError):
validate(make_project(overlays=[_banner(**bad)]), tmp_path)
@pytest.mark.parametrize("settings", [{}, CAM := {"layout": {"cam": {"x": 0.02, "y": 0.45, "w": 0.2, "h": 0.25}}}, HORIZONTAL])
def test_banner_ass_two_lines_animated_and_clear_of_captions(tmp_path, settings):
clip = {"session_id": 1, "start_s": 10.0, "end_s": 75.0, "peak_s": 50.0, "title": "Carregando o dilera no PvP do Rob Run!",
"source": "chat"}
cfg = layout.merge(settings)
data = editor.auto_project(clip, None, [Word(11, 11.4, "olha")], [], 100.0, cfg)
hook = data["overlays"][0]
assert hook["style"] == "banner" and hook["end"] == 3.0
p = validate(data, tmp_path)
ass = editor_render.build_project_ass(p, editor.effective_settings(cfg, p), "twitch.tv/x")
band = next(line for line in ass.splitlines() if ",Bar,," in line and "\\p1" in line and "&H00FF00&" in line)
text = next(line for line in ass.splitlines() if "CARREGANDO" in line)
assert "\\move(" in band and "\\move(" in text and "\\blur18" in text and "\\t(90,430,\\blur0)" in text
assert f"\\fn{layout.HOOK_FONT}" in text and text.count("\\N") <= 1 # no máximo 2 linhas, palavra inteira
g = editor_render.banner_layout(p["overlays"][0], layout.canvas_size(cfg))
size = editor.effective_settings(cfg, p)["caption"]["size"]
# A tarja não cobre a legenda: as legendas que aparecem enquanto o gancho está na tela ficam fora da faixa.
during = [line for line in ass.splitlines() if ",Caption,," in line and _ass_start(line) < hook["end"]]
assert during
for line in during:
y = int(re.search(r"\\pos\(\d+,(\d+)\)", line).group(1))
assert y + size <= g["top"] or y - size >= g["top"] + g["height"]
assert all(len(line) <= 40 for line in g["lines"])
def _ass_start(line: str) -> float:
h, m, s = line.split(",")[1].split(":")
return int(h) * 3600 + int(m) * 60 + float(s)
def test_hook_goes_right_below_the_camera_and_caption_steps_aside(tmp_path):
"""Pedido do dono (17/11/2026): com a câmera em cima o gancho vai logo abaixo dela (ele pôs 0,384 no editor com a
câmera em 0,34). Antes o automático ia para 0,14 — em cima do rosto."""
cam = {"layout": {"cam": {"x": 0.0037, "y": 0.4313, "w": 0.2013, "h": 0.2272}}}
cfg = layout.merge(cam)
assert layout.hook_y(cfg) == pytest.approx(0.384)
assert layout.hook_y(layout.merge({**cam, "hook": {"y": 0.5}})) == 0.5 # escolhido no editor de posição
assert layout.hook_y(layout.merge({})) != pytest.approx(0.384) # sem câmera: regra antiga (longe da legenda)
with pytest.raises(layout.LayoutError):
layout.validate({"hook": {"y": 0.99}})
assert layout.validate({"hook": {"y": None}})["hook"]["y"] is None
clip = {"session_id": 1, "start_s": 10.0, "end_s": 75.0, "peak_s": 50.0, "title": "Proibiu o clã de pegar loot", "source": "chat"}
data = editor.auto_project(clip, None, [Word(10.2, 10.6, "olha"), Word(20, 20.4, "depois")], [], 100.0, cfg)
assert data["overlays"][0]["y"] == pytest.approx(0.384)
p = validate(data, tmp_path)
ass = editor_render.build_project_ass(p, editor.effective_settings(cfg, p), "twitch.tv/x")
ys = {round(_ass_start(line)): int(re.search(r"\\pos\(\d+,(\d+)\)", line).group(1))
for line in ass.splitlines() if ",Caption,," in line}
assert ys[0] != ys[10] and ys[10] == layout.caption_y(editor.effective_settings(cfg, p)) # desvia e depois volta
def test_banner_shrinks_long_text_instead_of_cutting_words():
o = _banner(text="Uma frase bem comprida que não caberia em duas linhas no tamanho cheio do gancho {\\b1}", size=120)
g = editor_render.banner_layout(o, (1080, 1920))
assert len(g["lines"]) <= 2 and g["size"] < 120
assert " ".join(g["lines"]) == o["text"].upper() # nenhuma palavra cortada
events = editor_render.banner_events(o, (1080, 1920))
assert "{\\b1}" not in events[1][2] and "(/B1)" in events[1][2] # texto escapado
def _frame(video: Path, at: float, size: tuple[int, int]) -> bytes:
return subprocess.run([FFMPEG, "-v", "error", "-ss", f"{at:.2f}", "-i", str(video), "-frames:v", "1", "-f", "rawvideo",
"-pix_fmt", "rgb24", "-"], capture_output=True, check=True).stdout[: size[0] * size[1] * 3]
def _green_rows(frame: bytes, w: int, h: int) -> list[int]:
rows = []
for y in range(0, h, 4):
px = [frame[(y * w + x) * 3: (y * w + x) * 3 + 3] for x in range(0, w, 40)]
if sum(1 for r, g, b in px if g > 200 and r < 80 and b < 80) > len(px) * 0.6:
rows.append(y)
return rows
@pytest.mark.skipif(not (FFMPEG and FFPROBE), reason="FFmpeg não instalado")
@pytest.mark.parametrize("aspect", ["vertical", "horizontal"])
def test_real_render_banner(tmp_path, aspect):
seg = tmp_path / "dark.ts"
subprocess.run([FFMPEG, "-v", "error", "-f", "lavfi", "-i", "color=c=0x202060:size=640x360:rate=30:duration=6",
"-f", "lavfi", "-i", "sine=frequency=440:duration=6", "-c:v", "libx264", "-preset", "ultrafast", "-g", "15",
"-c:a", "aac", "-shortest", str(seg)], check=True)
words = [{"s": 1.0 + i * 0.4, "e": 1.3 + i * 0.4, "w": w} for i, w in enumerate("tá escutando tiro não é".split())]
data = make_project(source={"sessionId": 1, "lo": 0, "hi": 6}, settings={"format": {"aspect": aspect}},
cuts=[{"start": 0, "end": 5, "mode": None}], overlays=[_banner(end=3)],
captions={"enabled": True, "preset": "classic", "style": {}, "emphColor": "#22E36B", "words": words},
cover={"enabled": False, "t": 1})
p = validate(data, tmp_path, duration=6.0)
out = tmp_path / f"{aspect}.mp4"
editor_render.render_project(FFMPEG, FFPROBE, ["-c:v", "libx264", "-preset", "ultrafast"], [(seg, 0.0, 6.0)], p,
layout.merge(), "twitch.tv/x", out, tmp_path)
w, h = layout.FRAME_SIZES[aspect]
early, settled, after = _frame(out, 0.05, (w, h)), _frame(out, 1.5, (w, h)), _frame(out, 4.0, (w, h))
rows = _green_rows(settled, w, h)
assert rows and abs((min(rows) + max(rows)) / 2 / h - 0.2) < 0.05 # tarja assentada perto de 20 % da altura
assert len(_green_rows(early, w, h)) < len(rows) # no começo ela ainda está entrando
assert _green_rows(after, w, h) == [] # depois do gancho, some
# ---------------------------------------------------------------- 3. fontes empacotadas
def test_packaged_fonts_lock_files_and_licenses():
lock = json.loads((REPO_ROOT / "assets" / "fonts" / "fonts.lock.json").read_text(encoding="utf-8"))
families = [e["family"] for e in lock["files"]]
assert {"Luckiest Guy", "Bangers", "Anton", "Bebas Neue", "Poppins ExtraBold"} == set(families)
for e in lock["files"]:
assert hashlib.sha256((REPO_ROOT / e["path"]).read_bytes()).hexdigest() == e["sha256"]
assert (REPO_ROOT / e["licenseFile"]).is_file() and e["license"] in ("OFL-1.1", "Apache-2.0")
assert re.search(r"/google/fonts/[0-9a-f]{40}/", e["url"]) # URL presa a commit
assert Path(e["path"]).parent.as_posix() == "assets/fonts" # pasta plana (fontsdir não lê subpastas)
assert layout.font_files() == {e["family"]: e["path"] for e in lock["files"]}
assert set(families) <= set(layout.FONTS)
def test_packaged_fonts_have_portuguese_accents_and_matching_family_name():
ttlib = pytest.importorskip("fontTools.ttLib")
for family, path in layout.font_files().items():
font = ttlib.TTFont(REPO_ROOT / path)
cmap = font.getBestCmap()
assert all(ord(c) in cmap for c in "TÁ ESCUTANDO TIRO, NÃO É? ÇÃÕÂÊÔÍÓÚÀ".replace(" ", ""))
names = {r.nameID: r.toUnicode() for r in font["name"].names if r.platformID == 3}
assert family == names[1] # o nome usado no ASS é o da família (ID 1) do arquivo
def test_fontsdir_only_when_a_packaged_font_is_used():
assert layout.ass_filter("a.ass", "Style: Caption,Arial Black,84") == "ass=a.ass"
assert "fontsdir='" in layout.ass_filter("a.ass", "Style: Caption,Bangers,84")
assert "fontsdir='" in layout.ass_filter("a.ass", "{\\fnLuckiest Guy}OI")
def test_settings_route_lists_font_files(api): # noqa: F811
client, _engine, _root = api
body = client.get("/v1/sessions/1/settings", headers={"X-Service-Key": KEY}).json()
assert body["fontFiles"]["Bangers"] == "assets/fonts/Bangers-Regular.ttf" and "Bangers" in body["fonts"]
assert body["defaults"]["hook"]["style"] == "banner" and "slide" in body["hookAnims"]
@pytest.mark.skipif(not FFMPEG, reason="FFmpeg não instalado")
def test_packaged_font_is_really_used_in_render(tmp_path):
"""Mesmo texto acentuado com Bangers, com Arial Black e com uma família inexistente: Bangers sai diferente das
duas (o libass achou o arquivo empacotado)."""
words = [{"s": 0.0, "e": 0.9, "w": w} for w in ["TÁ"]] + [{"s": 0.95, "e": 1.9, "w": "ESCUTANDO"}]
def still(font: str) -> bytes:
p = validate(make_project(source={"sessionId": 1, "lo": 0, "hi": 6}, cuts=[{"start": 0, "end": 3, "mode": None}],
overlays=[], captions={"enabled": True, "preset": "classic", "style": {}, "emphColor": "#22E36B",
"words": words}, progress={"enabled": False}, cover={"enabled": False, "t": 1}), tmp_path, duration=6.0)
cfg = editor.effective_settings(layout.merge(), p)
cfg["caption"]["font"] = font
ass = editor_render.build_project_ass(p, cfg, "")
(tmp_path / "f.ass").write_text(ass, encoding="utf-8")
frame = tmp_path / "f.png"
subprocess.run([FFMPEG, "-y", "-v", "error", "-f", "lavfi", "-i", "color=c=0x303030:s=1080x1920:d=1", "-filter_complex",
f"[0:v]{layout.ass_filter('f.ass', ass)}[v]", "-map", "[v]", "-frames:v", "1", frame.name],
cwd=tmp_path, check=True)
return frame.read_bytes()
bangers, arial, missing = still("Bangers"), still("Arial Black"), still("Fonte Que Nao Existe")
assert bangers != arial and bangers != missing
def test_banner_entry_blurs_the_whole_letter_and_settles_identical():
"""Com contorno, o blur do libass só desfoca a borda: na entrada o preenchimento vem numa camada sem contorno
(borrada inteira, como no modelo do dono) e, do fim da entrada em diante, entra o evento assentado de sempre."""
events = editor_render.banner_events(_banner(), (1080, 1920))
fill, outline, settled = events[1], events[2], events[3]
assert r"\bord0" in fill[2] and r"\blur18\t(90,430,\blur0)" in fill[2] and fill[3] == (0.0, 0.43)
assert r"\1a&HFF&" in outline[2] and outline[0] < fill[0] # contorno sem preenchimento, por baixo
assert settled[3] == (0.43, None) and r"\move" not in settled[2] and r"\blur" not in settled[2]
assert r"\pos(540," in settled[2] and r"\bord8\shad4" in settled[2]