CenaForge: primeira versão pública

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>
This commit is contained in:
2026-11-17 16:35:09 -03:00
co-authored by Claude Opus 5.5
commit 84f30bbc2d
484 changed files with 74826 additions and 0 deletions
+399
View File
@@ -0,0 +1,399 @@
"""Escolha dos melhores momentos. Funções puras (sem E/S): recebem a linha do tempo e devolvem os trechos.
Ideia central: o chat reage DEPOIS do momento. Medimos a "empolgação" do chat por segundo (mensagens com peso:
risada, susto, hype e pedido de clip valem mais), comparamos com o normal recente da própria live (chat grande
tem muita mensagem o tempo todo; o que importa é o pico relativo) e, achado o pico, voltamos no tempo até onde a
reação começou e pegamos alguns segundos antes disso: é ali que aconteceu a coisa.
Sem chat (VOD), o sinal vem do volume do áudio (gritos, risadas) e de palavras de reação na transcrição.
Rosto do streamer (opcional, `face`): a série por segundo do rastreio (reaction.py). Reforça momentos do chat/áudio
(`reasons.face` + bônus limitado na nota) e cria momentos de fonte "face" só quando o áudio ou o chat também se
mexem no mesmo trecho — rosto sozinho nunca vira corte. Sem `face`, o resultado é idêntico ao de antes.
"""
from __future__ import annotations
import math
import re
import statistics
from collections import Counter
from dataclasses import dataclass, field, replace
from . import reaction
# Peso extra por categoria de reação. Uma mensagem pode somar mais de uma.
REACTION_PATTERNS: dict[str, tuple[re.Pattern[str], float]] = {
"risada": (re.compile(r"(k{3,}|kek|lul|lmao|lmfao|omegalul|icant|pepelaugh|haha|hehe|rsrs|ksks|😂|🤣|xd\b)", re.I), 1.0),
"susto": (re.compile(r"(caralho|crlh|caraca|nossa|meu deus|mds|wtf|omg|que isso|q isso|monkas|monkaw|\bhuh+\b|"
r"😱|😳|\?{3,}|!{3,})", re.I), 1.0),
"hype": (re.compile(r"(\bpog|pogchamp|poggers|\bw+\b|\bgg+\b|\bez\b|insano|absurdo|brabo|🔥)", re.I), 0.7),
# Palavra inteira: "clip5k1hmm" (emote) casava com \bclip e dava peso de pedido de clipe.
"clip": (re.compile(r"\b(clip|clips|clipa|clipe|clipou|clipar|clip it|clipit)\b", re.I), 3.0),
}
# Palavras faladas que indicam reação (modo sem chat).
SPOKEN_REACTION = re.compile(r"^(caralho|caraca|nossa|meu|deus|socorro|mano|nãããão|não|sim|vai|gente|que|isso|olha)$", re.I)
@dataclass(frozen=True)
class Params:
pre_s: float = 14.0 # quanto antes do início da reação o corte começa
post_s: float = 6.0 # quanto depois do pico o corte termina
# Duração do candidato: o motor troca pelos valores da configuração do corte de cada sessão (`duration`);
# estes são os mesmos padrões de layout.DEFAULTS (pedido do dono, 16/11/2026: cortes de 60 a 90 s).
min_s: float = 60.0
max_s: float = 90.0
threshold: float = 2.2 # pico precisa ser X vezes o normal recente do chat
audio_threshold: float = 2.0 # modo sem chat: z-score mínimo
min_gap_s: float = 45.0 # distância mínima entre dois picos
smooth_s: int = 5
baseline_s: int = 180
onset_ratio: float = 1.3 # o início da reação é onde a razão cai abaixo disto
max_onset_s: float = 30.0
settle_s: float = 12.0 # ao vivo: espera este tanto depois do fim do corte antes de fechar o pico
min_rate: float = 0.2 # mensagens/s mínimas no denominador (live com chat parado não vira pico por 2 msgs)
min_peak_messages: int = 12 # teto do mínimo de mensagens nos 8 s do pico (chat grande)
min_peak_floor: int = 4 # piso do mínimo (chat pequeno): 3 mensagens soltas nunca viram pico
min_reactions: int = 2 # mensagens de reação (risada/susto/hype/clip) nos 8 s do pico
sparse_rate: float = 0.5 # msg/s abaixo disso o chat é "fraco" e o áudio também propõe momentos
warmup_s: int = 60 # começo da gravação: ainda não há "normal" do chat para comparar
# --- rosto do streamer (reaction.py) ---
face_threshold: float = 3.0 # z mínimo da reação no rosto para anotar/reforçar um momento
face_bonus: float = 0.08 # nota extra por unidade de z do rosto num momento do chat/áudio…
face_bonus_max: float = 0.6 # …limitada a isto (o rosto reforça, não manda)
# Momento NOVO de fonte "face" (calibrado na sessão 3: com z ≥ 3 e apoio fraco saíam 32 momentos em 72 min,
# mais que os 21 do chat): reação forte no rosto E apoio de verdade no mesmo trecho.
face_source_threshold: float = 6.0 # z mínimo (= "forte")
face_support_audio_z: float = 1.5 # sinal do áudio suavizado (3 s) acima disto…
face_support_reactions: int = 2 # …ou pelo menos isto de mensagens de reação (texto ou emote) no chat
face_chat_after_s: float = 10.0 # o chat reage depois: conta até X s após o pico do rosto
face_score_scale: float = 0.4 # nota do momento "face" = z do rosto (até 10) × isto, na escala da razão do chat
@dataclass(frozen=True)
class ChatMessage:
t: float
text: str
user: str = ""
emotes: tuple[str, ...] = () # emotes da mensagem (Twitch, 7TV, BTTV, FFZ, Kick, emoji)
bonus: float = 0.0 # peso extra pelos emotes (base + aprendido do canal; ver emotes.py)
@dataclass(frozen=True)
class Word:
start: float
end: float
word: str
@dataclass
class Moment:
peak_s: float
start_s: float
end_s: float
score: float
source: str # "chat" ou "audio"
reasons: dict = field(default_factory=dict)
def message_weight(text: str) -> tuple[float, list[str]]:
weight, tags = 1.0, []
for tag, (pattern, bonus) in REACTION_PATTERNS.items():
if pattern.search(text):
weight += bonus
tags.append(tag)
return weight, tags
def per_second(duration_s: float, chat: list[ChatMessage]) -> list[float]:
n = max(0, int(math.ceil(duration_s)))
series = [0.0] * n
for message in chat:
i = int(message.t)
if 0 <= i < n:
series[i] += message_weight(message.text)[0] + message.bonus
return series
def smooth(series: list[float], window: int) -> list[float]:
"""Média móvel para trás (só usa o passado: o valor em t não depende do futuro)."""
out, acc = [], 0.0
for i, value in enumerate(series):
acc += value
if i >= window:
acc -= series[i - window]
out.append(acc / min(i + 1, window))
return out
def chat_ratio(series: list[float], p: Params) -> list[float]:
"""Razão entre a empolgação suavizada e o normal recente (mediana dos últimos `baseline_s`, sem os últimos 10 s)."""
smoothed = smooth(series, p.smooth_s)
ratio = []
for t, value in enumerate(smoothed):
window = smoothed[max(0, t - p.baseline_s): max(0, t - 10)]
if len(window) < 30: # começo da gravação: usa o que tiver
window = smoothed[: t + 1]
base = max(p.min_rate, statistics.median(window) if window else p.min_rate)
ratio.append(value / base)
return ratio
def zscores(series: list[float]) -> list[float]:
values = [v for v in series if v is not None and not math.isnan(v)]
if len(values) < 10:
return [0.0] * len(series)
mean = statistics.fmean(values)
sd = statistics.pstdev(values) or 1.0
return [((v - mean) / sd) if v is not None and not math.isnan(v) else 0.0 for v in series]
def audio_signal(duration_s: float, loudness: list[float | None], words: list[Word]) -> list[float]:
n = max(0, int(math.ceil(duration_s)))
loud = (list(loudness) + [None] * n)[:n]
z = zscores([v if v is not None else float("nan") for v in loud])
signal = [max(0.0, v) for v in z]
for word in words:
i = int(word.start)
if 0 <= i < n and SPOKEN_REACTION.match(word.word.strip(" .,!?…").lower()):
signal[i] += 0.5
return smooth(signal, 3)
def pick_peaks(score: list[float], threshold: float, min_gap_s: float, limit_s: float | None = None) -> list[int]:
"""Picos acima do limiar, do maior para o menor, sem dois a menos de `min_gap_s`."""
# Escolhe olhando a série inteira e só depois descarta os não assentados (após `limit_s`): assim, ao vivo,
# um pico maior que ainda está crescendo segura os pontos menores do começo da mesma explosão.
candidates = sorted((i for i in range(len(score)) if score[i] >= threshold), key=lambda i: -score[i])
chosen: list[int] = []
for i in candidates:
if all(abs(i - j) >= min_gap_s for j in chosen):
chosen.append(i)
return sorted(i for i in chosen if limit_s is None or i < limit_s)
def onset(score: list[float], peak: int, below: float, max_back_s: float) -> int:
t = peak
while t > 0 and peak - t < max_back_s and score[t - 1] >= below:
t -= 1
return t
def snap_to_words(start: float, end: float, words: list[Word], gap: float = 0.35, reach: float = 4.0) -> tuple[float, float]:
"""Não corta no meio de uma frase: recua o início até uma pausa e estica o fim até uma pausa (até `reach` s)."""
if not words:
return start, end
ordered = sorted(words, key=lambda w: w.start)
# Começos de frase (palavra depois de uma pausa) perto do início pedido; prefere o mais próximo ANTES dele.
starts = [
w.start for i, w in enumerate(ordered)
if start - reach <= w.start <= start + 0.5 and (i == 0 or w.start - ordered[i - 1].end >= gap)
]
before = [s for s in starts if s <= start]
new_start = (max(before) if before else min(starts)) - 0.15 if starts else start
new_end = end
for i, word in enumerate(ordered):
if end - 0.5 <= word.end <= end + reach:
pause_after = ordered[i + 1].start - word.end if i + 1 < len(ordered) else gap
if pause_after >= gap:
new_end = word.end + 0.25
break
return max(0.0, new_start), max(new_end, new_start + 1)
def fit_window(start: float, end: float, lo: float, hi: float, min_len: float, max_len: float,
keep: str = "end") -> tuple[float, float]:
"""Encaixa [start, end] em [lo, hi] com duração entre `min_len` e `max_len`. Longo demais: corta o lado oposto a
`keep`. Curto demais: cresce PARA TRÁS primeiro (o contexto vem antes da reação) e, se bater em `lo` (começo da
gravação/janela), para a frente até `hi`. Se nem assim couber (material menor que o mínimo), devolve o que der —
quem chama decide o que fazer (não inventa vídeo). Arredonda para fora (centésimos), nunca encurta."""
start, end = max(lo, start), min(hi, end)
if end < start:
end = start
if end - start > max_len:
if keep == "start":
end = start + max_len
else:
start = end - max_len
if end - start < min_len:
start = max(lo, end - min_len)
if end - start < min_len:
end = min(hi, start + min_len)
return math.floor(start * 100) / 100, math.ceil(end * 100 - 1e-6) / 100
def fit_length(start: float, end: float, peak: float, p: Params, duration_s: float) -> tuple[float, float]:
"""Duração do candidato: começa pelo menos 2 s antes do pico e fica entre `min_s` e `max_s` (o motor passa o
mínimo da configuração + 1 s). Antes a ordem permitia passar do máximo e, no fim da gravação, ficar curto."""
start = max(0.0, min(start, peak - 2))
return fit_window(start, end, 0.0, max(duration_s, end), p.min_s, p.max_s, keep="end")
def chat_reasons(chat: list[ChatMessage], start: float, end: float) -> dict:
inside = [m for m in chat if start <= m.t <= end]
tags: Counter[str] = Counter()
phrases: Counter[str] = Counter()
emotes: Counter[str] = Counter()
for message in inside:
tags.update(message_weight(message.text)[1])
emotes.update(set(message.emotes))
normalized = re.sub(r"\s+", " ", message.text.strip())[:40]
if normalized:
phrases[normalized.lower()] += 1
return {
"messages": len(inside),
"tags": dict(tags.most_common()),
"topMessages": [text for text, _ in phrases.most_common(5)],
"emotes": dict(emotes.most_common(8)),
}
def find_moments(
duration_s: float,
chat: list[ChatMessage],
loudness: list[float | None],
words: list[Word],
params: Params | None = None,
live: bool = False,
face: list[reaction.FaceSecond] | None = None,
) -> list[Moment]:
"""Melhores momentos da linha do tempo. `live=True` só devolve picos já "assentados" (fim + settle_s <= duração).
Chat com movimento → picos do chat. Chat fraco (média < `sparse_rate` msg/s) → picos do chat E do áudio
(gritos/risadas/palavras de reação), sem sobrepor; o juiz de IA filtra. Sem chat → só áudio.
`face`: série do rosto alinhada à linha do tempo (índice = segundo; `None`/vazia = sem rosto).
"""
p = params or Params()
use_chat = len(chat) >= 30
moments = _chat_moments(duration_s, chat, loudness, words, p, live) if use_chat else []
sparse = duration_s > 0 and len(chat) / duration_s < p.sparse_rate
if not use_chat or sparse:
for m in _audio_moments(duration_s, loudness, words, p, live):
if not any(overlaps(m.start_s, m.end_s, c.start_s, c.end_s) for c in moments):
moments.append(m)
if face:
moments += _face_moments(duration_s, chat if use_chat else [], loudness, words, face, moments, p, live)
return sorted(moments, key=lambda m: m.peak_s)
def _face_moments(duration_s: float, chat: list[ChatMessage], loudness: list[float | None], words: list[Word],
face: list[reaction.FaceSecond], moments: list[Moment], p: Params, live: bool) -> list[Moment]:
"""Anota o rosto nos momentos do chat/áudio (bônus limitado) e devolve os momentos novos de fonte "face"."""
reactions = reaction.reaction_moments(face, replace(reaction.ReactionParams(), threshold=p.face_threshold))
if not reactions:
return []
for m in moments:
near = [r for r in reactions if m.start_s - 2 <= r.peak_s <= m.end_s + 3]
if near:
best = max(near, key=lambda r: r.intensity)
m.reasons["face"] = best.to_json()
m.score = round(m.score + min(p.face_bonus_max, p.face_bonus * best.intensity), 3)
n = max(0, int(math.ceil(duration_s)))
# Sinal do áudio suavizado (3 s, igual ao da fonte "audio"): o z cru de 1 segundo passa de 1 por acaso em ~16 %
# dos segundos e não serviria de apoio.
loud = audio_signal(duration_s, loudness, words)
reacting = [m.t for m in chat if message_weight(m.text)[1] or m.emotes]
limit = duration_s - p.post_s - p.settle_s if live else None
out: list[Moment] = []
for r in sorted(reactions, key=lambda r: -r.intensity):
if r.intensity < p.face_source_threshold or (limit is not None and r.peak_s >= limit):
continue
lo, hi = max(0, r.onset_s - 2), min(n, r.peak_s + 4)
audio = max(loud[lo:hi], default=0.0)
chat_hits = sum(1 for t in reacting if r.onset_s - 2 <= t <= r.peak_s + p.face_chat_after_s)
# Rosto sozinho não vira corte: precisa de apoio do áudio (gritou/riu alto) ou do chat no mesmo trecho.
if audio < p.face_support_audio_z and chat_hits < p.face_support_reactions:
continue
start, end = snap_to_words(r.onset_s - p.pre_s, max(r.end_s, r.peak_s) + p.post_s, words)
start, end = fit_length(start, end, r.peak_s, p, duration_s)
if any(overlaps(start, end, m.start_s, m.end_s) for m in moments + out):
continue
if any(abs(r.peak_s - m.peak_s) < p.min_gap_s for m in out):
continue
reasons = {"peakRatio": round(r.intensity, 2), "onsetS": r.onset_s, "face": r.to_json(),
"support": {"audioZ": round(audio, 2), "chatReactions": chat_hits}}
if chat:
reasons |= chat_reasons(chat, r.onset_s - 2, r.peak_s + 3)
out.append(Moment(float(r.peak_s), start, end, round(min(10.0, r.intensity) * p.face_score_scale, 3), "face",
reasons))
return out
def _required_messages(counts_8s: list[int], t: int, p: Params) -> int:
"""Mínimo de mensagens nos 8 s do pico, proporcional ao chat daquela live (mediana recente × 3).
Medido em 17/11/2026: chat de 0,15 msg/s (skipnho) nunca chegava às 12 mensagens fixas e a live inteira ficava
sem corte; chat de ~0,6 msg/s (alanzoka) com 3 mensagens soltas não pode virar pico. Fica entre 4 e 12.
"""
window = counts_8s[max(0, t - p.baseline_s): max(0, t - 10)] or counts_8s[: t + 1]
typical = statistics.median(window) if window else 0
return int(max(p.min_peak_floor, min(p.min_peak_messages, math.ceil(typical * 3))))
def _chat_moments(duration_s: float, chat: list[ChatMessage], loudness: list[float | None], words: list[Word],
p: Params, live: bool) -> list[Moment]:
score, threshold = chat_ratio(per_second(duration_s, chat), p), p.threshold
loud_z = zscores([v if v is not None else float("nan") for v in (list(loudness) + [None] * len(score))[: len(score)]])
score = [s + 0.15 * max(0.0, z) for s, z in zip(score, loud_z)] # grito junto com o pico do chat soma um pouco
# Falso positivo medido na live real: chat calmo + 3 mensagens (uma com "clip") já dava razão 2,35, e o
# começo da gravação (sem "normal" para comparar) virava pico. Exige gente reagindo (relativo ao chat) e aquecimento.
counts, reacts = [0] * len(score), [0] * len(score)
for message in chat:
i = int(message.t)
if 0 <= i < len(counts):
counts[i] += 1
# Reação = texto de reação OU emote (público pequeno reage com emote em vez de "kkkk").
reacts[i] += 1 if (message_weight(message.text)[1] or message.emotes) else 0
prefix, rprefix = [0], [0]
for c, r in zip(counts, reacts):
prefix.append(prefix[-1] + c)
rprefix.append(rprefix[-1] + r)
counts_8s = [prefix[t + 1] - prefix[max(0, t - 7)] for t in range(len(score))] # mensagens nos últimos 8 s
for t in range(len(score)):
required = _required_messages(counts_8s, t, p)
reactions = rprefix[t + 1] - rprefix[max(0, t - 7)]
# Chat pequeno junta 4 "oi" por acaso: além do volume, exige reação de verdade (ou volume dobrado).
enough = counts_8s[t] >= required and (reactions >= p.min_reactions or counts_8s[t] >= 2 * required)
if t < p.warmup_s or not enough:
score[t] = min(score[t], threshold - 0.01)
return _build(score, threshold, p.onset_ratio, "chat", duration_s, chat, words, p, live)
def _audio_moments(duration_s: float, loudness: list[float | None], words: list[Word], p: Params, live: bool) -> list[Moment]:
score = audio_signal(duration_s, loudness, words)
return _build(score, p.audio_threshold, 0.8, "audio", duration_s, [], words, p, live)
def _build(score: list[float], threshold: float, below: float, source: str, duration_s: float,
chat: list[ChatMessage], words: list[Word], p: Params, live: bool) -> list[Moment]:
limit = duration_s - p.post_s - p.settle_s if live else None
moments = []
for peak in pick_peaks(score, threshold, p.min_gap_s, limit):
begin = onset(score, peak, below, p.max_onset_s)
start, end = begin - p.pre_s, peak + p.post_s
start, end = snap_to_words(start, end, words)
start, end = fit_length(start, end, peak, p, duration_s)
reasons = {"peakRatio": round(score[peak], 2), "onsetS": begin}
if chat:
reasons |= chat_reasons(chat, begin - 2, peak + 3)
moments.append(Moment(float(peak), start, end, round(score[peak], 3), source, reasons))
return moments
def overlaps(a_start: float, a_end: float, b_start: float, b_end: float, tolerance: float = 5.0) -> bool:
return a_start < b_end - tolerance and b_start < a_end - tolerance
def timeline(duration_s: float, chat: list[ChatMessage], loudness: list[float | None], params: Params | None = None) -> dict:
"""Séries por segundo para o gráfico do painel (mensagens/s, razão do chat, volume)."""
p = params or Params()
raw = per_second(duration_s, chat)
counts = [0] * len(raw)
for message in chat:
if 0 <= int(message.t) < len(counts):
counts[int(message.t)] += 1
return {
"messagesPerS": counts,
"ratio": [round(v, 2) for v in chat_ratio(raw, p)] if chat else [],
"loudnessDb": [None if v is None else round(v, 1) for v in loudness[: len(raw)]],
}