- roles.py: varredura, analista, editor e juiz, cada um com provedor, modelo, raciocínio (Codex), liga/desliga (o editor não desliga) e instruções do administrador somadas às padrão; gravado em settings `judge.roles`, com migração automática da configuração antiga (provedor/modelo único vira o de todos; o modelo do analista é respeitado). A reserva vale por papel. - Juiz de contexto (só texto): vê só o que vai no corte (+20 s antes/15 s depois marcados out=1), escreve o que um espectador frio entende e responde sim/não; context_judge.decide decide pelo código: aprova, ajusta o trecho e confere uma vez de novo, frase de contexto na tela (vira o texto de abertura do projeto) ou descarta com motivo em português (forçável). Corte manual só recebe aviso. - timeline.py: linha do tempo JSON curta (fala com falante, chat, rosto, volume e a frase de tela que a varredura/analista escrevem ao ver os quadros, em scene_notes); mosaico 4x2 (media.mosaic) no lugar dos quadros soltos; perfil do jogo enxuto. O formato antigo fica atrás da opção timelineJson. - Medição (F0): ai_calls por chamada (papel, IA, tamanho do prompt/imagens, tokens quando a CLI informa: codex --json, claude e gemini), avaliação do dono (owner_label: bom/ruim/sem contexto) e GET /v1/judge/report (taxa de aprovação, decisões do juiz, concordância). - Banco v17 (v16 fica reservada às expressões, como marcador sem efeito). - Testes: test_roles.py e test_context_judge.py; os testes bloqueiam qualquer CLI de IA real. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
299 lines
14 KiB
Python
299 lines
14 KiB
Python
"""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"]
|