Clipador: Equipe de IA (papéis com IA própria), juiz de contexto e linha do tempo JSON
- 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>
This commit is contained in:
co-authored by
Claude Opus 5.5
parent
5be6c09c16
commit
cb8450399d
@@ -0,0 +1,298 @@
|
||||
"""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"]
|
||||
Reference in New Issue
Block a user