Clipador em inglês (doc/clipador/IDIOMAS.md):
- Fonte en-US: analista, editor e varredura com prompts, glossário de chat e saída em inglês;
a mesma resposta traz o bloco `pt` (tradução para o painel, sem chamada extra).
- Fala do corte traduzida por frase (clips.translation_json, migração v13) e
POST /v1/clips/{id}/translate.
- caption.translation (só para desenvolver): português embaixo da legenda em inglês.
- Risada e gírias do chat em inglês na heurística (LMAO, LOL, 💀, 😭, no way, bruh...).
- Idioma do público → código do Whisper (en-US dava 422 no serviço de voz).
- Painel: bloco "Em português" no corte, análise/resumo em PT, título traduzido na lista,
coluna "Ao vivo" mostra a gravação ativa da fonte.
IA: monitor de uso do limite (ai-usage) e 4º provedor (Antigravity CLI).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
406 lines
20 KiB
Python
406 lines
20 KiB
Python
"""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
|
||
|
||
|
||
@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)]],
|
||
}
|