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>
706 lines
40 KiB
Python
706 lines
40 KiB
Python
"""Inteligência do Clipador além da heurística: contexto do jogo, varredura da IA, webcam e emotes que aprendem.
|
||
|
||
Pedido do usuário (17/11/2026), depois de uma live com chat pequeno (skipnho, 0,15 msg/s) passar 15 min sem corte:
|
||
- a IA precisa saber QUE JOGO é (categoria da plataforma, título, chat e a própria tela) e conhecer o jogo
|
||
(pesquisa na web, guardada por jogo);
|
||
- a IA precisa VER a tela (frames) e procurar momentos sozinha, mesmo sem pico de chat (varredura);
|
||
- achar a webcam do streamer para o layout câmera-em-cima;
|
||
- emotes da Twitch/7TV/BTTV/FFZ contam como reação e ganham peso por canal conforme os cortes aprovados.
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
import json
|
||
import logging
|
||
import re
|
||
import threading
|
||
import time
|
||
from pathlib import Path
|
||
from typing import TYPE_CHECKING
|
||
|
||
from . import clip_delete, layout
|
||
from .db import loads, now
|
||
from .emotes import EmoteCatalog, extract, learn_delta, message_bonus
|
||
from .face import FaceError, FaceUnavailable
|
||
from .hashtags import fold, to_tag
|
||
from .judge import JudgeError, build_scan_prompt, game_context, lang_key, output_language_note
|
||
from .scoring import fit_window
|
||
from .sources import parse_source
|
||
|
||
if TYPE_CHECKING: # pragma: no cover
|
||
from .worker import Engine
|
||
|
||
log = logging.getLogger("cenaforge_clipper.intel")
|
||
|
||
# faceTrack: rastreio do rosto do streamer (face.py) — reforça/cria cortes e vai em texto para o analista.
|
||
OPTION_DEFAULTS = {"scanEnabled": True, "scanIntervalS": 180, "vision": True, "camDetect": True, "faceTrack": True}
|
||
CAM_RETRY_S = 300 # câmera não achada enquanto grava: nova tentativa depois de mais 5 min de gravação
|
||
CAM_MAX_ATTEMPTS = 6 # falha sem rosto decidido (poucos quadros legíveis): no máximo isto de tentativas
|
||
GAME_CHECK_S = 600 # rechecar a categoria da live a cada 10 min (o streamer troca de jogo)
|
||
SCAN_FRAME_EVERY_S = 30
|
||
SCAN_MAX_FRAMES = 7
|
||
MEMORY_KEEP = 6
|
||
SCAN_MAX_MOMENTS = 2
|
||
SCAN_MIN_PROPOSAL = 4 # proposta da varredura abaixo disso nem vai aos juízes (economia)
|
||
|
||
|
||
class CamRetryLater(JudgeError):
|
||
"""Câmera local indisponível por um motivo passageiro (modelo/download): não é "sem câmera"."""
|
||
|
||
|
||
def game_id(name: str) -> str:
|
||
return re.sub(r"[^a-z0-9]+", "-", name.lower()).strip("-")[:60] or "desconhecido"
|
||
|
||
|
||
PROFILE_LISTS = ("mechanics", "clip_worthy", "avoid", "jargon", "news", "hashtags", "sources", "aliases", "end_triggers")
|
||
# Teto de cada lista (o resto: 20). Missões ficam à parte (objetos, até 120).
|
||
LIST_LIMITS = {"aliases": 10, "end_triggers": 12}
|
||
MAX_MISSIONS = 120
|
||
MAX_MISSION_TRIGGERS = 8
|
||
|
||
# Sementes: perfis prontos que vêm com o repositório (ex.: GTA VI). Importados na subida só se o jogo não existe.
|
||
SEEDS_DIR = Path(__file__).resolve().parent / "seeds" / "games"
|
||
|
||
|
||
def _clean_text_list(values, limit: int, item_chars: int = 300) -> list[str]:
|
||
items, seen = [], set()
|
||
for item in values or []:
|
||
text = str(item or "").strip()[:item_chars]
|
||
if text and text.lower() not in seen:
|
||
seen.add(text.lower())
|
||
items.append(text)
|
||
return items[:limit]
|
||
|
||
|
||
def clean_missions(values) -> list[dict]:
|
||
"""Missões: nome obrigatório (sem repetir), capítulo, resumo e até 8 gatilhos de fim (até 200 caracteres cada)."""
|
||
out, seen = [], set()
|
||
for raw in values or []:
|
||
if not isinstance(raw, dict):
|
||
continue
|
||
name = str(raw.get("name") or "").strip()[:160]
|
||
if not name or name.lower() in seen:
|
||
continue
|
||
seen.add(name.lower())
|
||
out.append({
|
||
"name": name,
|
||
"chapter": str(raw.get("chapter") or "").strip()[:120],
|
||
"summary": str(raw.get("summary") or "").strip()[:500],
|
||
"completion_triggers": _clean_text_list(raw.get("completion_triggers"), MAX_MISSION_TRIGGERS, 200),
|
||
})
|
||
if len(out) >= MAX_MISSIONS:
|
||
break
|
||
return out
|
||
|
||
|
||
def clean_profile(raw: dict) -> dict:
|
||
"""Normaliza um perfil de jogo (vindo da IA, da tradução ou da edição à mão): textos aparados, listas sem
|
||
vazios/duplicados, missões validadas. Hashtags viram tag de verdade ("rob run" → "#RobRun"; sem letra some),
|
||
comparadas sem acento/maiúscula."""
|
||
raw = raw if isinstance(raw, dict) else {}
|
||
out: dict = {k: str(raw.get(k) or "").strip()[:limit] for k, limit in (("name", 120), ("summary", 1500), ("genre", 120))}
|
||
for key in PROFILE_LISTS:
|
||
if key == "hashtags":
|
||
items, seen = [], set()
|
||
for item in raw.get(key) or []:
|
||
text = to_tag(str(item or "").strip()[:300]) or ""
|
||
if text and fold(text) not in seen:
|
||
seen.add(fold(text))
|
||
items.append(text)
|
||
out[key] = items[:20]
|
||
else:
|
||
out[key] = _clean_text_list(raw.get(key), LIST_LIMITS.get(key, 20))
|
||
out["missions"] = clean_missions(raw.get("missions"))
|
||
return out
|
||
|
||
|
||
def alias_ids(*profiles: dict | None) -> list[str]:
|
||
"""Ids normalizados dos outros nomes do jogo (das duas versões do perfil), sem repetir."""
|
||
ids: list[str] = []
|
||
for profile in profiles:
|
||
for alias in (profile or {}).get("aliases") or []:
|
||
gid = game_id(str(alias))
|
||
if gid != "desconhecido" and gid not in ids:
|
||
ids.append(gid)
|
||
return ids
|
||
|
||
|
||
class Intel:
|
||
def __init__(self, engine: "Engine"):
|
||
self.e = engine
|
||
self.catalog = EmoteCatalog()
|
||
self._weights: dict[str, tuple[float, dict[str, float]]] = {}
|
||
self._rooms_ready: set[str] = set()
|
||
self._game_checked: dict[int, float] = {}
|
||
self._cam_retry_at: dict[int, float] = {} # falha transitória da câmera local (modelo/download): só em memória
|
||
self.last_scan_error: str | None = None
|
||
saved = {r["key"]: r["value"] for r in engine.db.all("SELECT key, value FROM settings")}
|
||
self.opts = dict(OPTION_DEFAULTS)
|
||
for key in OPTION_DEFAULTS:
|
||
if f"opt_{key}" in saved:
|
||
self.opts[key] = json.loads(saved[f"opt_{key}"])
|
||
self.import_seeds()
|
||
|
||
# ---------------------------------------------------------------- sementes de jogos
|
||
def import_seeds(self, folder: Path | None = None) -> list[str]:
|
||
"""Importa os perfis de `seeds/games/*.json` ({name, aliases, researchedAt, sources, profileAi, profile}) que
|
||
ainda não existem no banco (por id ou alias). Nunca sobrescreve: o que você editou fica. Devolve os ids novos."""
|
||
added: list[str] = []
|
||
for path in sorted((folder or SEEDS_DIR).glob("*.json")):
|
||
try:
|
||
seed = json.loads(path.read_text(encoding="utf-8"))
|
||
name = str(seed.get("name") or "").strip()
|
||
if not name:
|
||
continue
|
||
ai = clean_profile({**(seed.get("profileAi") or {}), "name": name})
|
||
pt = clean_profile({**(seed.get("profile") or seed.get("profileAi") or {}), "name": name})
|
||
for profile in (ai, pt):
|
||
profile["aliases"] = profile["aliases"] or list(seed.get("aliases") or [])
|
||
profile["sources"] = profile["sources"] or list(seed.get("sources") or [])
|
||
gid = game_id(name)
|
||
if self.find_game(name) or any(self.find_game(a) for a in ai["aliases"]):
|
||
continue
|
||
self.e.db.run(
|
||
"INSERT INTO games (id, name, status, profile_json, profile_ai_json, aliases_json, model, researched_at,"
|
||
" translated_at) VALUES (?, ?, 'ready', ?, ?, ?, 'seed', ?, ?)",
|
||
gid, name[:120], json.dumps(pt, ensure_ascii=False), json.dumps(ai, ensure_ascii=False),
|
||
json.dumps(alias_ids(ai, pt)), seed.get("researchedAt") or now(), seed.get("researchedAt") or now())
|
||
added.append(gid)
|
||
log.info("jogo importado da semente %s: %s", path.name, name)
|
||
except (OSError, ValueError) as exc:
|
||
log.warning("semente de jogo %s inválida: %s", path.name, exc)
|
||
return added
|
||
|
||
# ---------------------------------------------------------------- opções (painel)
|
||
def set_options(self, values: dict) -> dict:
|
||
clean = {}
|
||
for key, value in values.items():
|
||
if key not in OPTION_DEFAULTS or value is None:
|
||
continue
|
||
if key == "scanIntervalS":
|
||
value = int(value)
|
||
if not 60 <= value <= 900:
|
||
raise JudgeError("intervalo da varredura vai de 60 a 900 s")
|
||
else:
|
||
value = bool(value)
|
||
clean[key] = value
|
||
self.opts.update(clean)
|
||
self.e.db.many("INSERT INTO settings (key, value) VALUES (?, ?) ON CONFLICT (key) DO UPDATE SET value = excluded.value",
|
||
[(f"opt_{k}", json.dumps(v)) for k, v in clean.items()])
|
||
return dict(self.opts)
|
||
|
||
# ---------------------------------------------------------------- canal / configuração do corte
|
||
@staticmethod
|
||
def channel_key(session: dict) -> str:
|
||
source = parse_source(session["url"])
|
||
return source.channel_id if source.channel else ""
|
||
|
||
def settings_for(self, session: dict) -> dict:
|
||
channel = None
|
||
if session.get("channel_id"):
|
||
channel = self.e.db.get("SELECT settings_json FROM channels WHERE id = ?", session["channel_id"])
|
||
return layout.merge(loads(channel["settings_json"], {}) if channel else {}, loads(session.get("settings_json"), {}))
|
||
|
||
# ---------------------------------------------------------------- emotes
|
||
def ingest_chat(self, session_id: int, channel_key: str, room_id: str | None,
|
||
batch: list[tuple[float, str, str, list[str]]]) -> None:
|
||
if room_id:
|
||
if room_id not in self._rooms_ready:
|
||
self.e.db.run("UPDATE sessions SET room_id = ? WHERE id = ? AND room_id IS NULL", room_id, session_id)
|
||
# Baixa o catálogo do canal fora da linha do chat (APIs externas podem demorar).
|
||
self._rooms_ready.add(room_id)
|
||
threading.Thread(target=self.catalog.names, args=(room_id,), daemon=True).start()
|
||
catalog = self.catalog.cached(room_id)
|
||
rows, seen = [], []
|
||
for wall, user, text, twitch_emotes in batch:
|
||
found = extract(text, twitch_emotes, catalog)
|
||
rows.append((session_id, wall, user, text, json.dumps([n for n, _ in found], ensure_ascii=False) if found else None))
|
||
seen.extend(found)
|
||
self.e.db.many("INSERT INTO chat (session_id, wall, user, text, emotes) VALUES (?, ?, ?, ?, ?)", rows)
|
||
if channel_key and seen:
|
||
ts = now()
|
||
self.e.db.many(
|
||
"INSERT INTO emotes (channel_key, name, source, uses, weight, first_seen, last_seen) VALUES (?, ?, ?, 1, 0, ?, ?)"
|
||
" ON CONFLICT (channel_key, name) DO UPDATE SET uses = uses + 1, last_seen = excluded.last_seen",
|
||
[(channel_key, name, source, ts, ts) for name, source in seen])
|
||
|
||
def weights(self, channel_key: str) -> dict[str, float]:
|
||
cached = self._weights.get(channel_key)
|
||
if cached and time.time() - cached[0] < 30:
|
||
return cached[1]
|
||
rows = self.e.db.all("SELECT name, weight FROM emotes WHERE channel_key = ? AND weight != 0", channel_key)
|
||
weights = {r["name"]: r["weight"] for r in rows}
|
||
self._weights[channel_key] = (time.time(), weights)
|
||
return weights
|
||
|
||
def bonus(self, emotes: list[str], channel_key: str) -> float:
|
||
return message_bonus(emotes, self.weights(channel_key)) if emotes else 0.0
|
||
|
||
def learn_from_clip(self, clip: dict, positive: bool, factor: float = 1.0, mark: bool = False) -> int:
|
||
"""Emotes da reação do corte (−10 s a +6 s do pico) ganham (aprovado) ou perdem (rejeitado) peso no canal."""
|
||
session = self.e.db.get("SELECT * FROM sessions WHERE id = ?", clip["session_id"])
|
||
if not session or (mark and clip.get("learned")):
|
||
return 0
|
||
key = self.channel_key(session)
|
||
if not key:
|
||
return 0
|
||
tl = self.e.load_timeline(session["id"], max(0.0, clip["peak_s"] - 120))
|
||
names = {e for m in tl["chat"] if clip["peak_s"] - 10 <= m.t <= clip["peak_s"] + 6 for e in m.emotes}
|
||
delta = learn_delta(positive) * factor
|
||
self.e.db.many("UPDATE emotes SET weight = MAX(-1.0, MIN(3.0, weight + ?)) WHERE channel_key = ? AND name = ?",
|
||
[(delta, key, n) for n in names])
|
||
if mark:
|
||
self.e.db.run("UPDATE clips SET learned = 1 WHERE id = ?", clip["id"])
|
||
self._weights.pop(key, None)
|
||
return len(names)
|
||
|
||
# ---------------------------------------------------------------- jogo
|
||
def check_game(self, session: dict, force: bool = False) -> None:
|
||
"""Categoria atual da live (Streamlink) → jogo da sessão; troca registrada; perfil pesquisado se novo."""
|
||
if session["kind"] != "live":
|
||
return
|
||
last = self._game_checked.get(session["id"], 0)
|
||
if not force and time.time() - last < GAME_CHECK_S:
|
||
return
|
||
self._game_checked[session["id"]] = time.time()
|
||
meta = self.e.check_meta(session["url"])
|
||
if not meta:
|
||
return
|
||
if meta.get("title") and not session.get("title"):
|
||
self.e.db.run("UPDATE sessions SET title = ? WHERE id = ?", meta["title"][:200], session["id"])
|
||
category = (meta.get("category") or "").strip()
|
||
if category and category != session.get("game") and session.get("game_source") != "user":
|
||
self.set_game(session["id"], category, "platform")
|
||
|
||
def set_game(self, session_id: int, name: str, source: str) -> None:
|
||
session = self.e.db.get("SELECT * FROM sessions WHERE id = ?", session_id)
|
||
if not session:
|
||
return
|
||
history = loads(session["games_json"], [])
|
||
history.append({"game": name, "source": source, "atS": session["duration_s"], "at": now()})
|
||
self.e.db.run("UPDATE sessions SET game = ?, game_source = ?, games_json = ? WHERE id = ?",
|
||
name[:120], source, json.dumps(history[-20:], ensure_ascii=False), session_id)
|
||
gid = game_id(name)
|
||
if not self.find_game(name):
|
||
self.e.db.run("INSERT INTO games (id, name, status) VALUES (?, ?, 'pending')", gid, name[:120])
|
||
|
||
def research_pending(self) -> None:
|
||
if not self.e.judge.enabled:
|
||
return # IA desligada: o jogo fica 'pending' até ligar (antes: um WARNING no log a cada 30 s)
|
||
for game in self.e.db.all("SELECT * FROM games WHERE status = 'pending' LIMIT 1"):
|
||
self.research(game["id"])
|
||
|
||
def research(self, gid: str) -> dict:
|
||
"""Pesquisa na web EM INGLÊS (missões e gatilhos inclusos) → versão da IA; depois traduz para português (a que
|
||
o painel mostra). Tradução falhou: as duas ficam em inglês e `error` explica (o jogo continua utilizável)."""
|
||
game = self.e.db.get("SELECT * FROM games WHERE id = ?", gid)
|
||
if not game:
|
||
raise JudgeError("jogo não encontrado")
|
||
if not self.e.judge.enabled:
|
||
raise JudgeError("IA desligada: escolha uma IA (Codex, Claude ou Gemini) para pesquisar o jogo")
|
||
title = (self.e.db.get("SELECT title FROM sessions WHERE game = ? ORDER BY id DESC LIMIT 1", game["name"]) or {}).get("title", "")
|
||
notes = [n.get("text", "") for n in loads(game.get("notes_json"), []) if n.get("text")]
|
||
try:
|
||
ai = clean_profile(self.e.judge.research_game(game["name"], title, notes))
|
||
model = self.e.judge.responder() # quem DE FATO respondeu (pode ter sido a IA reserva)
|
||
except (JudgeError, json.JSONDecodeError) as exc:
|
||
self.e.db.run("UPDATE games SET status = 'error', error = ? WHERE id = ?", str(exc)[:300], gid)
|
||
raise JudgeError(str(exc)) from exc
|
||
self.e.db.run("UPDATE games SET profile_ai_json = ?, model = ?, researched_at = ? WHERE id = ?",
|
||
json.dumps(ai, ensure_ascii=False), model, now(), gid)
|
||
pt, error = self._translated(ai, "pt-BR")
|
||
self._store(gid, pt=pt, ai=ai, translated=error is None, error=error)
|
||
return ai
|
||
|
||
def _translated(self, profile: dict, target: str) -> tuple[dict, str | None]:
|
||
"""(perfil traduzido, None) ou (o próprio perfil, motivo) se a IA está desligada ou a tradução falhou."""
|
||
if not self.e.judge.enabled:
|
||
return profile, "IA desligada: a outra versão do perfil não foi atualizada"
|
||
try:
|
||
out = clean_profile(self.e.judge.translate_game(profile, target))
|
||
except (JudgeError, json.JSONDecodeError) as exc:
|
||
return profile, f"tradução falhou: {exc}"[:300]
|
||
# A tradução nunca mexe em nome, hashtags, fontes e outros nomes (a IA às vezes "traduz" o que não devia).
|
||
for key in ("name", "hashtags", "sources", "aliases"):
|
||
out[key] = profile.get(key) or out.get(key)
|
||
if len(out.get("missions") or []) != len(profile.get("missions") or []):
|
||
return profile, "tradução perdeu missões: a outra versão ficou igual à original"
|
||
return out, None
|
||
|
||
def _store(self, gid: str, *, pt: dict | None = None, ai: dict | None = None, translated: bool = False,
|
||
error: str | None = None, edited: bool = False, extra_sql: str = "", extra: tuple = ()) -> None:
|
||
"""Grava as versões que vieram (None = não mexe), os outros nomes (união das duas) e o estado."""
|
||
game = self.e.db.get("SELECT profile_json, profile_ai_json FROM games WHERE id = ?", gid) or {}
|
||
pt_now = pt if pt is not None else loads(game.get("profile_json"), None)
|
||
ai_now = ai if ai is not None else loads(game.get("profile_ai_json"), None)
|
||
self.e.db.run(
|
||
"UPDATE games SET status = 'ready', profile_json = ?, profile_ai_json = ?, aliases_json = ?, error = ?,"
|
||
" translated_at = CASE WHEN ? THEN ? ELSE translated_at END,"
|
||
" edited_at = CASE WHEN ? THEN ? ELSE edited_at END" + extra_sql + " WHERE id = ?",
|
||
json.dumps(pt_now, ensure_ascii=False) if pt_now is not None else None,
|
||
json.dumps(ai_now, ensure_ascii=False) if ai_now is not None else None,
|
||
json.dumps(alias_ids(ai_now, pt_now)), error, int(translated), now(), int(edited), now(), *extra, gid)
|
||
|
||
def save_profile(self, gid: str, profile: dict, lang: str = "pt") -> dict:
|
||
"""Grava a edição à mão na versão `lang` ("pt" = a que você lê; "en" = a da IA) e traduz para a outra. Com a IA
|
||
desligada, grava só essa e a outra fica como estava (`translatedAt` não muda: o painel avisa que está velha)."""
|
||
if not self.e.db.get("SELECT 1 FROM games WHERE id = ?", gid):
|
||
raise JudgeError("jogo não encontrado")
|
||
clean = clean_profile(profile)
|
||
target = "en-US" if lang == "pt" else "pt-BR"
|
||
other, error = self._translated(clean, target)
|
||
translated = error is None
|
||
if lang == "pt":
|
||
self._store(gid, pt=clean, ai=other if translated else None, translated=translated, error=error, edited=True)
|
||
else:
|
||
self._store(gid, ai=clean, pt=other if translated else None, translated=translated, error=error, edited=True)
|
||
return clean
|
||
|
||
def translate(self, gid: str) -> dict:
|
||
"""Gera a versão da IA (inglês) a partir da portuguesa — para jogos de antes da v12."""
|
||
game = self.e.db.get("SELECT * FROM games WHERE id = ?", gid)
|
||
if not game:
|
||
raise JudgeError("jogo não encontrado")
|
||
if not self.e.judge.enabled:
|
||
raise JudgeError("IA desligada: escolha uma IA (Codex, Claude ou Gemini) para traduzir o perfil")
|
||
pt = loads(game["profile_json"], None)
|
||
if not pt:
|
||
raise JudgeError("o jogo ainda não tem perfil para traduzir")
|
||
ai, error = self._translated(clean_profile(pt), "en-US")
|
||
if error:
|
||
raise JudgeError(error)
|
||
self._store(gid, ai=ai, translated=True)
|
||
return ai
|
||
|
||
def refine(self, gid: str, instruction: str, search: bool = True, section: str = "",
|
||
history: list[dict] | None = None) -> tuple[dict, str]:
|
||
"""Pede à IA para acrescentar/corrigir algo no perfil (opcionalmente numa seção). Aplica na versão em inglês
|
||
(a da IA; jogo antigo sem ela: na portuguesa) e traduz para português. O pedido fica guardado e volta em toda
|
||
pesquisa. Devolve (perfil em português, resposta curta da IA em português)."""
|
||
game = self.e.db.get("SELECT * FROM games WHERE id = ?", gid)
|
||
if not game:
|
||
raise JudgeError("jogo não encontrado")
|
||
if not self.e.judge.enabled:
|
||
raise JudgeError("IA desligada: escolha uma IA (Codex, Claude ou Gemini) para editar o perfil pela IA")
|
||
current = (loads(game.get("profile_ai_json"), None) or loads(game["profile_json"], None)
|
||
or clean_profile({"name": game["name"]}))
|
||
try:
|
||
data = self.e.judge.refine_game(game["name"], current, instruction, search, section, history)
|
||
model = self.e.judge.responder() # antes da tradução, que também passa pelo juiz
|
||
except json.JSONDecodeError as exc:
|
||
raise JudgeError(f"a IA devolveu um perfil inválido: {exc}") from exc
|
||
reply = str(data.get("reply") or "").strip()[:600]
|
||
ai = clean_profile(data)
|
||
pt, error = self._translated(ai, "pt-BR")
|
||
notes = loads(game.get("notes_json"), [])
|
||
notes.append({"text": instruction, "at": now(), **({"section": section} if section else {})})
|
||
self._store(gid, ai=ai, pt=pt, translated=error is None, error=error, edited=True,
|
||
extra_sql=", notes_json = ?, model = ?",
|
||
extra=(json.dumps(notes[-30:], ensure_ascii=False), model))
|
||
return pt, reply
|
||
|
||
def add_game(self, name: str, notes: str = "") -> str:
|
||
"""Cadastra um jogo pelo painel (antes só nascia da categoria da live) e pesquisa em segundo plano.
|
||
Já existe (pelo id ou por outro nome dele) → UserError 409."""
|
||
name = name.strip()[:120]
|
||
if not name:
|
||
raise ValueError("Diga o nome do jogo.")
|
||
existing = self.find_game(name)
|
||
if existing:
|
||
raise LookupError(f"“{existing['name']}” já está na lista.")
|
||
gid = game_id(name)
|
||
note_list = [{"text": notes.strip()[:1500], "at": now()}] if notes.strip() else []
|
||
self.e.db.run("INSERT INTO games (id, name, status, notes_json) VALUES (?, ?, 'pending', ?)",
|
||
gid, name, json.dumps(note_list, ensure_ascii=False))
|
||
if self.e.judge.enabled:
|
||
threading.Thread(target=self._research_quietly, args=(gid,), name=f"game-{gid}", daemon=True).start()
|
||
return gid
|
||
|
||
def _research_quietly(self, gid: str) -> None:
|
||
try:
|
||
self.research(gid)
|
||
except JudgeError as exc:
|
||
log.warning("pesquisa do jogo %s falhou: %s", gid, exc)
|
||
|
||
def delete_game(self, gid: str) -> None:
|
||
"""Apaga o jogo. Sessões não mudam; se o jogo voltar numa live, nasce de novo e é pesquisado."""
|
||
if not self.e.db.get("SELECT 1 FROM games WHERE id = ?", gid):
|
||
raise JudgeError("jogo não encontrado")
|
||
self.e.db.run("DELETE FROM games WHERE id = ?", gid)
|
||
|
||
def delete_note(self, gid: str, index: int) -> None:
|
||
"""Esquece um pedido (ele deixa de voltar nas próximas pesquisas; o perfil atual não muda)."""
|
||
game = self.e.db.get("SELECT notes_json FROM games WHERE id = ?", gid)
|
||
if not game:
|
||
raise JudgeError("jogo não encontrado")
|
||
notes = loads(game["notes_json"], [])
|
||
if 0 <= index < len(notes):
|
||
notes.pop(index)
|
||
self.e.db.run("UPDATE games SET notes_json = ? WHERE id = ?", json.dumps(notes, ensure_ascii=False), gid)
|
||
|
||
def find_game(self, name: str) -> dict | None:
|
||
"""Linha do jogo pelo nome: id normalizado ou, se não achar, um jogo que tem esse nome entre os outros nomes."""
|
||
gid = game_id(name or "")
|
||
if not name or gid == "desconhecido":
|
||
return None
|
||
row = self.e.db.get("SELECT * FROM games WHERE id = ?", gid)
|
||
if row:
|
||
return row
|
||
# aliases_json é uma lista JSON de ids: procura o id entre aspas (LIKE barato, confere no Python).
|
||
for row in self.e.db.all("SELECT * FROM games WHERE aliases_json LIKE ?", f'%"{gid}"%'):
|
||
if gid in loads(row.get("aliases_json"), []):
|
||
return row
|
||
return None
|
||
|
||
def profile(self, name: str) -> dict | None:
|
||
"""Perfil que vai para a IA: a versão em inglês; jogo antigo, sem ela, usa a portuguesa."""
|
||
row = self.find_game(name)
|
||
if not row or row["status"] != "ready":
|
||
return None
|
||
return loads(row.get("profile_ai_json"), None) or loads(row["profile_json"], None)
|
||
|
||
def session_game(self, session: dict) -> tuple[str, dict | None]:
|
||
"""(nome do jogo, perfil) da sessão — o mesmo critério do contexto: jogo confirmado por você vale sozinho;
|
||
senão a categoria e, sem perfil dela, o jogo que a IA viu na tela."""
|
||
confirmed = session.get("game_source") == "user" and bool(session.get("game"))
|
||
game, screen = session.get("game") or "", session.get("screen_game") or ""
|
||
profile = self.profile(game)
|
||
if profile or confirmed:
|
||
return game, profile
|
||
screen_profile = self.profile(screen) if screen.lower() not in ("", "desconhecido") else None
|
||
return (screen, screen_profile) if screen_profile else (game or ("" if screen.lower() == "desconhecido" else screen), None)
|
||
|
||
def lang(self, session: dict) -> str:
|
||
"""'en' = fonte em inglês (juízes em inglês, tradução para o painel); 'pt' = o resto."""
|
||
return lang_key(session.get("language") or self.e.settings.language)
|
||
|
||
def context(self, session: dict) -> str:
|
||
memory = loads(session.get("memory_json"), [])
|
||
confirmed = session.get("game_source") == "user" and bool(session.get("game"))
|
||
profile = self.profile(session.get("game", "")) or (None if confirmed else self.profile(session.get("screen_game", "")))
|
||
text = game_context(session.get("game", ""), session.get("screen_game", ""), profile, session.get("title", ""),
|
||
" | ".join(m["summary"] for m in memory[-3:] if m.get("summary")), confirmed=confirmed,
|
||
lang=self.lang(session))
|
||
# Sessão em outro idioma (fonte gringa): o editor e a varredura escrevem título/legenda nesse idioma.
|
||
note = output_language_note(session.get("language") or self.e.settings.language)
|
||
return f"{text}\n{note}" if note else text
|
||
|
||
# ---------------------------------------------------------------- frames
|
||
def frames(self, session: dict, times: list[float], tag: str) -> list[tuple[float, Path]]:
|
||
if not self.opts["vision"]:
|
||
return []
|
||
segments = [(self.e.repo_path(s["file"]), s["start_s"], s["end_s"])
|
||
for s in self.e.db.all("SELECT * FROM segments WHERE session_id = ? AND deleted = 0 ORDER BY idx", session["id"])]
|
||
out_dir = self.e.repo_path(session["dir"]) / "frames"
|
||
frames = []
|
||
for t in times:
|
||
try:
|
||
frames.append((t, self.e.grab_frame(segments, t, out_dir / f"{tag}-{int(t)}.jpg")))
|
||
except Exception as exc: # noqa: BLE001 - sem frame a IA decide só pelo texto
|
||
log.info("frame %.0fs indisponível: %s", t, exc)
|
||
return frames
|
||
|
||
# ---------------------------------------------------------------- webcam
|
||
def maybe_detect_cam(self, session: dict) -> None:
|
||
"""Acha a câmera no início da sessão. A detecção local (YuNet) não precisa de IA, visão nem juiz ligados."""
|
||
if not self.opts["camDetect"] or time.time() < self._cam_retry_at.get(session["id"], 0.0):
|
||
return
|
||
saved = loads(session.get("cam_json"), None)
|
||
# Sem rosto na 1ª olhada (tela de "já volto" no começo da live): tenta de novo mais tarde enquanto grava.
|
||
# Falha sem rosto decidido (poucos quadros legíveis): tenta de novo pelo relógio, também em VOD/sessão parada.
|
||
due = saved and ((saved.get("retryAfterS") and session["duration_s"] >= saved["retryAfterS"])
|
||
or (saved.get("retryAt") is not None and time.time() >= saved["retryAt"]
|
||
and saved.get("attempts", 1) < CAM_MAX_ATTEMPTS))
|
||
if saved and not due:
|
||
return
|
||
analyzed = self.e.db.get("SELECT COUNT(*) AS n FROM segments WHERE session_id = ? AND analyzed = 1", session["id"])["n"]
|
||
if analyzed < 2:
|
||
return
|
||
if self.settings_for(session)["layout"]["cam"]:
|
||
self.e.db.run("UPDATE sessions SET cam_json = ? WHERE id = ?",
|
||
json.dumps({"skipped": "já definida", "source": "manual"}), session["id"])
|
||
return
|
||
try:
|
||
self.detect_cam(session["id"], apply=True)
|
||
except CamRetryLater as exc:
|
||
# Modelo indisponível/download falhou: nada a ver com a live. Não grava "sem câmera" (seria permanente e
|
||
# o rastreio marcaria tudo no_cam); tenta de novo em 5 min.
|
||
self._cam_retry_at[session["id"]] = time.time() + CAM_RETRY_S
|
||
log.warning("câmera da sessão %s: %s (nova tentativa em %d s)", session["id"], exc, CAM_RETRY_S)
|
||
except JudgeError as exc:
|
||
# Sem frame legível e sem IA: registra para não repetir a cada 30 s, com nova tentativa marcada
|
||
# (por tempo de gravação enquanto grava; pelo relógio em qualquer estado, até CAM_MAX_ATTEMPTS vezes).
|
||
attempts = (saved or {}).get("attempts", 0) + 1
|
||
self.e.db.run("UPDATE sessions SET cam_json = ? WHERE id = ?", json.dumps(
|
||
{"hasWebcam": False, "cam": None, "source": "yunet", "error": str(exc)[:200], "at": now(),
|
||
"retryAt": time.time() + CAM_RETRY_S, "attempts": attempts,
|
||
**({"retryAfterS": session["duration_s"] + CAM_RETRY_S} if session["status"] == "recording" else {})},
|
||
ensure_ascii=False), session["id"])
|
||
|
||
def detect_cam(self, session_id: int, apply: bool = False, use_ai: bool = False) -> dict:
|
||
"""Onde está a webcam. Primeiro local (YuNet + reaction.locate_cam, sem custo de IA); a IA só entra se o
|
||
local não achar rosto (e a IA estiver ligada com visão) ou se pedirem (`use_ai`). `cam_json.source` diz
|
||
quem achou: yunet | ai | manual."""
|
||
session = self.e.db.get("SELECT * FROM sessions WHERE id = ?", session_id)
|
||
if not session or session["duration_s"] < 5:
|
||
raise JudgeError("gravação curta demais para achar a câmera")
|
||
ai_ready = self.opts["vision"] and self.e.judge.enabled
|
||
local, local_error, transient = None, "", False
|
||
if not use_ai:
|
||
try:
|
||
local = self.e.face.locate(session)
|
||
except FaceUnavailable as exc: # modelo/biblioteca/download: passageiro, não é "sem câmera"
|
||
local_error, transient = str(exc), True
|
||
log.info("câmera local da sessão %s indisponível: %s", session_id, exc)
|
||
except FaceError as exc:
|
||
local_error = str(exc)
|
||
log.info("câmera local da sessão %s falhou: %s", session_id, exc)
|
||
if local is not None and (local["hasWebcam"] or not ai_ready):
|
||
result = local
|
||
if not local["hasWebcam"] and session["status"] == "recording":
|
||
result["retryAfterS"] = session["duration_s"] + CAM_RETRY_S
|
||
self.e.db.run("UPDATE sessions SET cam_json = ? WHERE id = ?", json.dumps(result, ensure_ascii=False), session_id)
|
||
# Câmera em tela cheia (só o streamer) não vira layout câmera-em-cima; o rastreio usa o quadro inteiro.
|
||
if local["hasWebcam"] and not local["fullFrame"] and apply:
|
||
try:
|
||
rect = layout.validate({"layout": {"cam": local["cam"]}})["layout"]["cam"]
|
||
except layout.LayoutError:
|
||
rect = None
|
||
if rect:
|
||
self._apply_cam(session, rect)
|
||
return result
|
||
if not ai_ready:
|
||
if transient:
|
||
raise CamRetryLater(f"detector de rosto indisponível agora ({local_error}); tente de novo em instantes")
|
||
raise JudgeError(f"não deu para achar a câmera sem a IA ({local_error or 'sem rosto'}); ligue a visão ou marque à mão")
|
||
d = session["duration_s"]
|
||
frames = self.frames(session, [d * 0.25, d * 0.55, max(1.0, d - 8)], "cam")
|
||
if not frames:
|
||
raise JudgeError("sem frames (visão desligada ou blocos apagados)")
|
||
data = self.e.judge.detect_cam([p for _, p in frames])
|
||
rect = None
|
||
if data.get("has_webcam"):
|
||
try:
|
||
rect = layout.validate({"layout": {"cam": {k: data[k] for k in ("x", "y", "w", "h")}}})["layout"]["cam"]
|
||
except layout.LayoutError:
|
||
rect = None
|
||
result = {"hasWebcam": bool(data.get("has_webcam")), "cam": rect, "gameOnScreen": data.get("game_on_screen", ""),
|
||
"frame": self.e.rel(frames[-1][1]), "at": now(), "source": "ai"}
|
||
self.e.db.run("UPDATE sessions SET cam_json = ? WHERE id = ?", json.dumps(result, ensure_ascii=False), session_id)
|
||
if rect and apply:
|
||
self._apply_cam(session, rect)
|
||
if result["gameOnScreen"] and result["gameOnScreen"].lower() not in ("desconhecido", "não identificável"):
|
||
self.e.db.run("UPDATE sessions SET screen_game = ? WHERE id = ?", result["gameOnScreen"][:120], session_id)
|
||
return result
|
||
|
||
def _apply_cam(self, session: dict, rect: dict) -> None:
|
||
"""Câmera achada vira padrão do canal (se o canal não tiver uma); sem canal, vale para a sessão."""
|
||
if session.get("channel_id"):
|
||
row = self.e.db.get("SELECT settings_json FROM channels WHERE id = ?", session["channel_id"])
|
||
current = loads(row["settings_json"], {}) if row else {}
|
||
if row and not (current.get("layout") or {}).get("cam"):
|
||
current.setdefault("layout", {})["cam"] = rect
|
||
self.e.db.run("UPDATE channels SET settings_json = ? WHERE id = ?", json.dumps(current), session["channel_id"])
|
||
return
|
||
current = loads(session.get("settings_json"), {})
|
||
if not (current.get("layout") or {}).get("cam"):
|
||
current.setdefault("layout", {})["cam"] = rect
|
||
self.e.db.run("UPDATE sessions SET settings_json = ? WHERE id = ?", json.dumps(current), session["id"])
|
||
|
||
# ---------------------------------------------------------------- varredura
|
||
def scan_due(self, session: dict, analyzed_until: float) -> tuple[float, float] | None:
|
||
if not (self.opts["scanEnabled"] and self.e.judge.enabled):
|
||
return None
|
||
if session["status"] == "recording" and session["kind"] == "vod":
|
||
return None # VOD baixa mais rápido que o tempo real: varre quando terminar
|
||
lo = session["scanned_until"]
|
||
hi = lo + self.opts["scanIntervalS"]
|
||
if hi <= analyzed_until:
|
||
return lo, hi
|
||
if session["status"] in ("processing", "stopped") and analyzed_until - lo >= 20:
|
||
return lo, analyzed_until # fim da gravação: varre o resto
|
||
return None
|
||
|
||
def scan_session(self, session: dict) -> int | None:
|
||
"""Varre a próxima janela pronta. None = nada a varrer agora; senão, quantos cortes criou."""
|
||
if not (self.opts["scanEnabled"] and self.e.judge.enabled):
|
||
return None
|
||
tl = self.e.load_timeline(session["id"], max(0.0, session["scanned_until"] - 200))
|
||
window = self.scan_due(session, tl["analyzedUntil"])
|
||
if not window:
|
||
return None
|
||
lo, hi = window
|
||
cfg = self.settings_for(session)
|
||
dur = cfg["duration"]
|
||
back_lo = max(0.0, lo - dur["backtrackS"])
|
||
step = max(SCAN_FRAME_EVERY_S, (hi - lo) / SCAN_MAX_FRAMES)
|
||
times = [lo + step / 2 + i * step for i in range(int((hi - lo) // step) or 1)][:SCAN_MAX_FRAMES]
|
||
frames = self.frames(session, times, "scan")
|
||
existing = [(c["start_s"], c["end_s"], c["title"]) for c in self.e.db.all(
|
||
"SELECT start_s, end_s, title FROM clips WHERE session_id = ? AND end_s > ? AND start_s < ?", session["id"], back_lo, hi)]
|
||
existing += clip_delete.mark_spans(self.e.db, session["id"], back_lo, hi) # apagados não voltam pela varredura
|
||
prompt = build_scan_prompt(self.e.streamer_name(session), session["platform"], lo, hi, back_lo, tl["words"],
|
||
tl["chat"], self.context(session), frames, existing, dur["minS"], dur["maxS"],
|
||
lang=self.lang(session))
|
||
created = 0
|
||
try:
|
||
data = self.e.judge.scan(prompt, [p for _, p in frames], lang=self.lang(session))
|
||
self.last_scan_error = None
|
||
except (JudgeError, json.JSONDecodeError) as exc:
|
||
# Avança mesmo assim: repetir a mesma janela com a CLI quebrada só gastaria cota.
|
||
self.last_scan_error = str(exc)[:300]
|
||
log.warning("varredura %s %.0f–%.0fs falhou: %s", session["id"], lo, hi, exc)
|
||
data = {"moments": [], "summary": "", "screen_game": ""}
|
||
proposals = data.get("moments", [])[:SCAN_MAX_MOMENTS]
|
||
for moment in proposals:
|
||
if self._insert_scan_moment(session, moment, back_lo, hi, dur, existing):
|
||
created += 1
|
||
# Quantas propostas a IA fez e quantas viraram candidato (as outras: nota < SCAN_MIN_PROPOSAL, curtas ou em
|
||
# cima de um corte). Antes não ficava registrado (diagnóstico de 17/11/2026: impossível saber se a varredura
|
||
# não propôs nada ou se foi barrada).
|
||
log.info("varredura %s %.0f–%.0fs: %d proposta(s), %d candidato(s)", session["id"], lo, hi, len(proposals), created)
|
||
memory = loads(session.get("memory_json"), [])
|
||
if data.get("summary") or proposals:
|
||
item = {"fromS": lo, "toS": hi, "summary": str(data.get("summary") or "")[:240],
|
||
"proposals": len(proposals), "created": created}
|
||
if data.get("summary_pt"): # fonte em inglês: o resumo vai em inglês à IA e em português ao painel
|
||
item["summaryPt"] = str(data["summary_pt"])[:240]
|
||
memory.append(item)
|
||
screen = str(data.get("screen_game") or "")
|
||
if screen.lower() in ("desconhecido", "não identificável", "nao identificavel", "unknown"):
|
||
screen = ""
|
||
self.e.db.run("UPDATE sessions SET scanned_until = ?, memory_json = ?, screen_game = CASE WHEN ? != '' THEN ? ELSE screen_game END WHERE id = ?",
|
||
hi, json.dumps(memory[-MEMORY_KEEP:], ensure_ascii=False), screen, screen[:120], session["id"])
|
||
if screen and not session.get("game"):
|
||
self.set_game(session["id"], screen, "screen") # sem categoria (YouTube/VOD): o jogo vem da tela
|
||
return created
|
||
|
||
def _insert_scan_moment(self, session: dict, m: dict, lo: float, hi: float, dur: dict, existing: list) -> bool:
|
||
"""Momento proposto pela varredura vira CANDIDATO: passa pelos dois juízes (analista + editor) como os do chat."""
|
||
try:
|
||
# Mínimo + 1 s de verdade: se o fim bate no fim da janela, o início recua (fit_window).
|
||
start, end = fit_window(float(m["start_s"]), float(m["end_s"]), lo, hi,
|
||
layout.min_target({"duration": dur}), float(dur["maxS"]), keep="start")
|
||
score = max(0.0, min(10.0, float(m["score"])))
|
||
except (KeyError, TypeError, ValueError):
|
||
return False
|
||
if end - start < min(10.0, dur["minS"]) or score < SCAN_MIN_PROPOSAL:
|
||
return False
|
||
from .scoring import overlaps # import local: evita ciclo na carga do módulo
|
||
|
||
if any(overlaps(start, end, a, b) for a, b, _ in existing):
|
||
return False
|
||
ts = now()
|
||
reasons = {"via": "varredura", "scanFromS": lo, "scanToS": hi, "proposalScore": score,
|
||
"proposalTitle": str(m.get("title", ""))[:100], "proposalReason": str(m.get("reason", ""))[:300]}
|
||
pt = m.get("pt") if isinstance(m.get("pt"), dict) else {}
|
||
if pt.get("title") or pt.get("reason"): # fonte em inglês: a mesma proposta em português para o painel
|
||
reasons |= {"proposalTitlePt": str(pt.get("title", ""))[:100], "proposalReasonPt": str(pt.get("reason", ""))[:300]}
|
||
self.e.db.run(
|
||
"INSERT INTO clips (session_id, peak_s, start_s, end_s, score, source, reasons_json, status, created_at, updated_at)"
|
||
" VALUES (?, ?, ?, ?, ?, 'ai', ?, 'candidate', ?, ?)",
|
||
session["id"], round((start + end) / 2, 2), round(start, 2), round(end, 2), score,
|
||
json.dumps(reasons, ensure_ascii=False), ts, ts)
|
||
existing.append((start, end, ""))
|
||
return True
|