"""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]] = { # Chat em inglês (fonte gringa, 18/11/2026): a risada lá é LMAO/LOL/💀/😭 e "I'm dead", não "kkkk". "risada": (re.compile(r"(k{3,}|kek|lul|lmao+|lmfao|omegalul|icant|pepelaugh|haha|hehe|rsrs|ksks|😂|🤣|xd\b|" r"\blo+l+\b|\brofl\b|💀|☠️?|😭|\bi'?m dead\b|\bim crying\b|\bdying\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,}|\bno+ ?wa+y+\b|\bna+h+\b|\bbru+h+\b|\bholy\b|\bjesus\b|" r"\boh my god\b|\bwhat the\b)", re.I), 1.0), "hype": (re.compile(r"(\bpog|pogchamp|poggers|\bw+\b|\bgg+\b|\bez\b|insano|absurdo|brabo|🔥|" r"\blet'?s ?go+\b|\bletsgo+\b|\bshe+sh\b|\bclutch\b|\bcracked\b|\bgoated\b|\binsane\b|" r"\bclap\b|\bdub\b)", 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|clip that|clipped)\b", re.I), 3.0), } # Palavras faladas que indicam reação (modo sem chat), em português e em inglês (fonte gringa). SPOKEN_REACTION = re.compile(r"^(caralho|caraca|nossa|meu|deus|socorro|mano|nãããão|não|sim|vai|gente|que|isso|olha|" r"bro|bruh|dude|yo|what|no+|oh|wow|holy|fuck|shit|wait|god|jesus|yes+|bro+)$", 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 # Quem falou (doc/clipador/FALANTES.md): "" ou "streamer" = o streamer; "other1", "other2"… = outra pessoa (colega no # Discord, voz do jogo). Vazio = não atribuído — conta como streamer (o comportamento de antes). speaker: 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)]], }