"""Linha do tempo em JSON curto (v1): o vídeo "lido" como texto barato para a IA (doc/clipador/EQUIPE-IA.md). Uma linha JSON por instante (JSON Lines), chaves curtas — a legenda das chaves vai uma vez no prompt —, segundos inteiros da gravação e campos vazios omitidos. Só com o que já existe (nenhum modelo novo): | chave | conteúdo | de onde vem | | --- | --- | --- | | `t`, `d` | início e duração da entrada | pausas da fala, troca de falante ou no máximo 8 s | | `v` | o que está na tela (frase curta) | a IA que já vê os frames (varredura/analista), guardada em `scene_notes` | | `sp` | fala literal (até ~25 palavras); `[other1] …` = outra pessoa | Whisper + falantes | | `face` | expressão do streamer + intensidade 0–9 (`laugh.7`) | série do rosto (face.FaceService.dense + reaction) | | `lvl` | volume relativo ao normal da live, 0–9 (3 = normal) | dBFS por segundo já medido | | `chat` | `"mensagens\\|emote×n\\|frase mais repetida"` | chat da sessão | | `out` | 1 = fora do corte (o espectador NÃO vê) — só no prompt do juiz | — | Comportamento antigo (transcrição + chat + frames soltos) continua atrás da opção `timelineJson` (intel.opts). """ from __future__ import annotations import json import logging import re import statistics from collections import Counter from dataclasses import dataclass, field from typing import TYPE_CHECKING from .scoring import ChatMessage, Word if TYPE_CHECKING: # pragma: no cover from .worker import Engine log = logging.getLogger("cenaforge_clipper.timeline") STEP_MAX_S = 8.0 # uma entrada nunca passa disso (gameplay contínuo quase não tem corte de plano) COARSE_STEP_S = 20.0 # trecho de "volta" da varredura: resumido PAUSE_S = 1.2 # pausa na fala que fecha a entrada (se ela já tem MIN_ENTRY_S) MIN_ENTRY_S = 4.0 FACE_MIN = 3 # expressão abaixo disso (z do rosto) é ruído: fica de fora LOUD_LVL, QUIET_LVL = 6, 1 # volume só aparece quando foge do normal (alto ou silêncio) PHRASE_CHARS = 32 SP_WORDS = 25 COARSE_SP_WORDS = 12 NORMAL_LVL = 3 # Rótulos do rosto (reaction.label) → token curto em inglês (as chaves e valores da linha do tempo são em inglês). FACE_TOKENS = {"risada": "laugh", "grito": "shout", "susto": "scare", "choque": "shock", "confuso": "confused", "raiva": "anger"} LEGEND = { "en": ("Timeline (JSON Lines; one entry per moment; seconds of the recording). Keys: t=start, d=duration, " "v=what is on screen (short), sp=speech, literal ([other1] = someone else talking, not the streamer), " "face=streamer expression.intensity 0-9, lvl=loudness vs. the stream's normal 0-9 (3=normal), " "chat=messages|top emote×count|most repeated message, out=1 → OUTSIDE the clip (the viewer does NOT see it). " "Missing key = nothing notable."), "pt": ("Linha do tempo (JSON Lines; uma entrada por instante; segundos da gravação). Chaves: t=início, d=duração, " "v=o que está na tela (curto), sp=fala literal ([other1] = outra pessoa falando, não o streamer), " "face=expressão do streamer.intensidade 0-9, lvl=volume em relação ao normal da live 0-9 (3=normal), " "chat=mensagens|emote mais usado×vezes|mensagem mais repetida, out=1 → FORA do corte (o espectador NÃO vê). " "Chave ausente = nada a notar."), } @dataclass class Evidence: """Tudo que a linha do tempo de uma janela usa. `face` = (segundo, token, intensidade z); `scenes` = (t, texto).""" words: list[Word] chat: list[ChatMessage] loudness: list[float | None] face: list[tuple[int, str, float]] = field(default_factory=list) scenes: list[tuple[float, str]] = field(default_factory=list) # ---------------------------------------------------------------- coleta (motor → Evidence) def face_marks(engine: "Engine", session: dict, lo: float, hi: float) -> list[tuple[int, str, float]]: """Expressões do streamer por segundo em [lo, hi], pelo que o rastreio já gravou (sem rodar nada novo). Sem câmera, rastreio desligado ou plano B sem expressões: lista vazia.""" try: from . import reaction from .face import OpenSeeFaceTracker face = engine.face if not face.enabled or not face.has_cam(session): return [] if face.session_backend(session["id"]) == OpenSeeFaceTracker.name: return [] seconds = face.dense(session["id"], max(0.0, lo - 240), hi) if not any(s.smile is not None for s in seconds if lo <= s.t <= hi): return [] zs = reaction.channel_z(seconds, face.params) signal = reaction.reaction_signal(seconds, params=face.params) marks = [] for second, z, value in zip(seconds, zs, signal): if not lo <= second.t <= hi or z is None: continue label = reaction.label(second, z, face.params) if label and label != "neutro": marks.append((int(second.t), FACE_TOKENS.get(label, label), float(value or 0.0))) return marks except Exception as exc: # noqa: BLE001 - sem rosto a linha do tempo segue sem `face` log.info("rosto para a linha do tempo indisponível: %s", exc) return [] def scene_lines(engine: "Engine", session_id: int, lo: float, hi: float) -> list[tuple[float, str]]: """Frases de tela guardadas (varredura e analista). Do analista primeiro quando os dois descreveram o mesmo t.""" rows = engine.db.all("SELECT t, source, text FROM scene_notes WHERE session_id = ? AND t >= ? AND t <= ? ORDER BY t", session_id, lo, hi) rows.sort(key=lambda r: (r["t"], r["source"] != "analyst")) return [(float(r["t"]), r["text"]) for r in rows] def save_scene_lines(engine: "Engine", session_id: int, source: str, lines: object, tiles: list[float]) -> int: """Grava as frases `v` que a IA escreveu para cada quadro (`n` = nº do quadro, 1 = primeiro). Devolve quantas.""" if not isinstance(lines, list) or not tiles: return 0 rows = [] for item in lines: if not isinstance(item, dict): continue try: n = int(item.get("n")) except (TypeError, ValueError): continue text = " ".join(str(item.get("v") or "").split())[:120] if 1 <= n <= len(tiles) and text: rows.append((session_id, round(tiles[n - 1], 1), source, text, _now())) if rows: engine.db.many("INSERT INTO scene_notes (session_id, t, source, text, created_at) VALUES (?, ?, ?, ?, ?)" " ON CONFLICT (session_id, t, source) DO UPDATE SET text = excluded.text", rows) return len(rows) def _now() -> str: from .db import now return now() def collect(engine: "Engine", session: dict, tl: dict, lo: float, hi: float) -> Evidence: """Evidência da janela [lo, hi] a partir da linha do tempo já carregada (`Engine.load_timeline`).""" return Evidence(words=[w for w in tl["words"] if lo - 1 <= w.start <= hi + 1], chat=[m for m in tl["chat"] if lo - 1 <= m.t <= hi + 1], loudness=tl["loudness"], face=face_marks(engine, session, lo, hi), scenes=scene_lines(engine, session["id"], lo, hi)) # ---------------------------------------------------------------- entradas def boundaries(words: list[Word], lo: float, hi: float, step: float = STEP_MAX_S, split_speech: bool = True) -> list[float]: """Onde cada entrada começa: pausa na fala, troca de quem fala ou no máximo `step` segundos. `split_speech=False` (resumo): só pelo passo.""" cuts = [lo] last_end: float | None = None last_sp: str | None = None for w in sorted((w for w in words if lo <= w.start < hi), key=lambda w: w.start): while w.start - cuts[-1] > step: cuts.append(cuts[-1] + step) cur = cuts[-1] speaker = w.speaker or "streamer" new_speaker = last_sp is not None and speaker != last_sp pause = last_end is not None and w.start - last_end > PAUSE_S and w.start - cur >= MIN_ENTRY_S if ((split_speech and (new_speaker or pause)) or w.start - cur >= step) and w.start > cur + 0.5: cuts.append(w.start) last_end, last_sp = w.end, speaker while hi - cuts[-1] > step: cuts.append(cuts[-1] + step) if hi - cuts[-1] < 0.5 and len(cuts) > 1: cuts.pop() return cuts + [hi] def _speech(words: list[Word], limit: int) -> str: parts: list[str] = [] current = None count = 0 for w in words: speaker = w.speaker or "streamer" if speaker != current: if speaker != "streamer": parts.append(f"[{speaker}]") elif current is not None: parts.append("[streamer]") current = speaker parts.append(w.word.strip()) count += 1 if count >= limit: parts.append("…") break return " ".join(p for p in parts if p) def _chat(messages: list[ChatMessage], coarse: bool) -> str: if not messages: return "" emotes = Counter(e for m in messages for e in set(m.emotes)) top = "" if emotes: name, n = emotes.most_common(1)[0] top = f"{name}×{n}" phrase = "" if not coarse: # Só o que o chat REPETE (reação coletiva); resposta a alguém (@) e comando (!) não contam. texts = Counter(re.sub(r"\s+", " ", m.text.strip().lower())[:PHRASE_CHARS] for m in messages if m.text.strip() and not m.text.lstrip().startswith(("@", "!"))) if texts: text, n = texts.most_common(1)[0] if n >= 2: phrase = text return "|".join((str(len(messages)), top, phrase)).rstrip("|") def _level(loudness: list[float | None], a: float, b: float, normal: float | None) -> int | None: values = [v for v in loudness[max(0, int(a)): max(int(a) + 1, int(b))] if v is not None] if not values or normal is None: return None return max(0, min(9, round(NORMAL_LVL + (max(values) - normal) / 4))) def normal_level(loudness: list[float | None], lo: float, hi: float) -> float | None: """Volume "normal" da live em volta da janela (mediana dos segundos com som).""" values = [v for v in loudness[max(0, int(lo) - 120): int(hi) + 1] if v is not None and v > -60] return statistics.median(values) if values else None def entries(ev: Evidence, lo: float, hi: float, *, coarse: bool = False, clip: tuple[float, float] | None = None, sp_words: int | None = None) -> list[dict]: """Entradas da janela. `coarse` = resumo (passo maior, fala curta, sem rosto/volume baixos). `clip` = (início, fim) do corte: as entradas fora dele saem marcadas `out: 1` (prompt do juiz: o espectador não vê) e nenhuma entrada atravessa o início ou o fim do corte.""" if clip is not None: start, end = clip out_items: list[dict] = [] for a, b, outside in ((lo, min(start, hi), True), (max(lo, start), min(end, hi), False), (max(lo, end), hi, True)): if b - a < 0.3: continue for item in entries(ev, a, b, coarse=coarse, sp_words=sp_words): out_items.append({"t": item.pop("t"), "d": item.pop("d"), **({"out": 1} if outside else {}), **item}) return out_items step = COARSE_STEP_S if coarse else STEP_MAX_S limit = sp_words or (COARSE_SP_WORDS if coarse else SP_WORDS) cuts = boundaries(ev.words, lo, hi, step, split_speech=not coarse) normal = normal_level(ev.loudness, lo, hi) out: list[dict] = [] used_scenes: set[int] = set() for a, b in zip(cuts, cuts[1:]): if b - a < 0.3: continue item: dict = {"t": int(round(a)), "d": max(1, int(round(b - a)))} scenes = [(i, text) for i, (t, text) in enumerate(ev.scenes) if a <= t < b and i not in used_scenes] if scenes: used_scenes.update(i for i, _ in scenes[:2]) item["v"] = " / ".join(dict.fromkeys(text for _, text in scenes[:2])) words = [w for w in ev.words if a <= w.start < b] if words: item["sp"] = _speech(words, limit) marks = [m for m in ev.face if a <= m[0] < b] if marks: _t, token, value = max(marks, key=lambda m: m[2]) intensity = max(0, min(9, round(value))) if intensity >= (FACE_MIN + 1 if coarse else FACE_MIN): item["face"] = f"{token}.{intensity}" level = _level(ev.loudness, a, b, normal) if level is not None and (level >= LOUD_LVL or level <= QUIET_LVL): item["lvl"] = level chat = _chat([m for m in ev.chat if a <= m.t < b], coarse) if chat: item["chat"] = chat out.append(item) return out def render(header: dict, items: list[dict]) -> str: dump = lambda obj: json.dumps(obj, ensure_ascii=False, separators=(",", ":")) # noqa: E731 return "\n".join([dump(header), *(dump(i) for i in items)]) def build(ev: Evidence, lo: float, hi: float, header: dict, *, budget_chars: int = 9000, coarse_until: float | None = None, clip: tuple[float, float] | None = None) -> str: """JSONL da janela dentro do orçamento de caracteres: se passar, a fala de cada entrada encurta (25 → 12 → 6 palavras) e, por último, o trecho mais antigo vira resumo. `coarse_until` = a parte [lo, coarse_until) já sai resumida (a "volta" da varredura).""" for sp_words in (SP_WORDS, COARSE_SP_WORDS, 6): items: list[dict] = [] split = coarse_until if coarse_until is not None and lo < coarse_until < hi else None if split is not None: items += entries(ev, lo, split, coarse=True, clip=clip) items += entries(ev, split, hi, clip=clip, sp_words=sp_words) else: items += entries(ev, lo, hi, clip=clip, sp_words=sp_words) text = render(header, items) if len(text) <= budget_chars: return text return text[:budget_chars].rsplit("\n", 1)[0] def legend(lang: str) -> str: return LEGEND["en" if lang == "en" else "pt"]