Clipador: detecção do jogo cruzando categoria e tela (confiança, evidência e sugestão de troca)

Trabalho de outra sessão, commitado na sincronização de 18/11/2026 (doc/clipador/DETECCAO-JOGO.md).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Mateuus
2026-11-18 05:08:57 -03:00
co-authored by Claude Opus 5.5
parent e4a5bc026c
commit 44bb961d1a
13 changed files with 780 additions and 41 deletions
+164
View File
@@ -0,0 +1,164 @@
"""Detecção do jogo da live: junta as pistas e decide qual é o jogo, com o grau de certeza.
Pedido do dono (18/11/2026): se ninguém lembrou de dizer o jogo, o Clipador descobre sozinho a cada ~3 min cruzando
várias fontes (a API da plataforma, o título, o que a IA lê na tela, o chat e a fala) e deixa o usuário
confirmar ou trocar. Este módulo é só a regra de decisão (sem banco, sem IA) para ser testável.
Pistas (`source`):
- platform: categoria da live (Streamlink/API). Autoridade da plataforma, mas pode estar abreviada, errada ou
genérica ("Just Chatting").
- screen: o jogo que a IA vê nos frames (logo, HUD, texto na tela), com a confiança que ela mesma declarou.
- title: o título da live cita um jogo conhecido.
- chat / speech: o chat e a fala dos últimos minutos citam um jogo conhecido (o nome ou um dos outros nomes).
Estados (`status`) do resultado:
- agreed: duas ou mais fontes independentes apontam o mesmo jogo.
- probable: uma fonte boa sozinha (ex.: só a categoria).
- conflict: a categoria e a tela (ou outras fontes fortes) apontam jogos diferentes — pergunta ao usuário.
- unknown: nenhuma pista útil.
"""
from __future__ import annotations
import re
import unicodedata
from dataclasses import dataclass, field
# Peso máximo de cada fonte (a força da pista, 0–1, multiplica). A categoria e a tela se equivalem de propósito:
# quando divergem, quem decide é o usuário (conflito), não um empate arbitrário.
SOURCE_WEIGHT = {"platform": 0.55, "screen": 0.5, "title": 0.25, "chat": 0.35, "speech": 0.35}
STRONG_SOURCES = ("platform", "screen")
CONFIDENCE = {"high": 1.0, "medium": 0.7, "low": 0.4}
AGREED_MIN = 0.6 # nota mínima para "várias fontes concordam"
PROBABLE_MIN = 0.34 # só a tela com confiança "média" (0,5 × 0,7 = 0,35) já vale como "provável"
CLEAR_LEAD = 0.25 # vantagem do 1º sobre o 2º para não ser conflito
CHAT_MIN_MESSAGES = 2 # uma mensagem solta citando um jogo é ruído
CHAT_FULL_AT = 6 # mensagens que dão força 1
SPEECH_FULL_AT = 3
# Categorias que não são jogo: não valem como pista de jogo (mas ficam registradas).
GENERIC_CATEGORIES = {
"just-chatting", "irl", "special-events", "music", "art", "asmr", "talk-shows-podcasts", "talk-shows",
"sports", "food-drink", "travel-outdoors", "pools-hot-tubs-beaches", "science-technology", "politics",
"software-and-game-development", "animals-aquariums-zoos", "fitness-health", "makers-crafting", "slots",
"games-demos", "just-sleeping", "retro", "gambling", "podcasts", "variety", "bate-papo", "so-bate-papo",
"unknown", "desconhecido", "nao-identificavel", "nenhum", "none", "n-a",
}
def deaccent(text: str) -> str:
return "".join(c for c in unicodedata.normalize("NFKD", text or "") if not unicodedata.combining(c))
def slug(text: str) -> str:
"""Sem acento ("Só Bate-papo" → "so-bate-papo"), minúsculo, palavras ligadas por hífen."""
return re.sub(r"[^a-z0-9]+", "-", deaccent(text).lower()).strip("-")[:60]
def is_generic(name: str) -> bool:
return not slug(name) or slug(name) in GENERIC_CATEGORIES
def form_ok(form: str) -> bool:
"""Forma de nome boa para procurar em texto solto: curta demais vira falso positivo ("it", "go")."""
return len(form) >= 4 or (len(form) >= 3 and any(c.isdigit() for c in form))
def count_mentions(texts: list[str], forms_by_game: dict[str, set[str]]) -> dict[str, int]:
"""Em quantas mensagens/frases cada jogo é citado. `forms_by_game`: id do jogo → nomes (já em `slug`).
O texto vira `-a-b-c-` e a forma `-gta-6-` precisa aparecer inteira (palavra inteira, sem pegar pedaço)."""
out: dict[str, int] = {}
wanted = {gid: [f"-{f}-" for f in forms if form_ok(f)] for gid, forms in forms_by_game.items()}
for text in texts:
# Duas leituras do texto: sem acento ("pokemon") e como o id do jogo foi gerado, que não tira acento
# (`intel.game_id("Pokémon")` = "pok-mon"). Casar com qualquer uma.
padded = (f"-{slug_all(text)}-", f"-{slug_all(text, fold=False)}-")
for gid, needles in wanted.items():
if any(n in p for n in needles for p in padded):
out[gid] = out.get(gid, 0) + 1
return out
def slug_all(text: str, fold: bool = True) -> str:
"""Como `slug`, sem o corte de 60 caracteres (textos longos: a fala de uns minutos). `fold=False` mantém os
acentos como separador (igual ao `game_id` do Clipador)."""
return re.sub(r"[^a-z0-9]+", "-", (deaccent(text) if fold else text or "").lower()).strip("-")
@dataclass
class Evidence:
source: str
game: str # nome como a fonte disse
gid: str # id canônico (resolvido pelo chamador: categoria "Grand Theft Auto VI" e tela "GTA 6" → o mesmo)
strength: float = 1.0 # 0–1
detail: str = ""
def score(self) -> float:
return SOURCE_WEIGHT.get(self.source, 0.1) * max(0.0, min(1.0, self.strength))
@dataclass
class Candidate:
gid: str
game: str
score: float = 0.0
evidence: list[Evidence] = field(default_factory=list)
@property
def sources(self) -> list[str]:
return sorted({e.source for e in self.evidence})
def view(self) -> dict:
return {"gid": self.gid, "game": self.game, "score": round(self.score, 2),
"sources": [{"source": e.source, "game": e.game, "strength": round(e.strength, 2), "detail": e.detail}
for e in self.evidence]}
@dataclass
class Decision:
status: str # agreed | probable | conflict | unknown
top: Candidate | None
candidates: list[Candidate]
def view(self) -> dict:
return {"status": self.status, "top": self.top.view() if self.top else None,
"candidates": [c.view() for c in self.candidates[:4]]}
def screen_strength(confidence: str) -> float:
return CONFIDENCE.get((confidence or "").strip().lower(), 0.7)
def fuse(evidence: list[Evidence]) -> Decision:
"""Pistas → candidatos (ruído-ou: cada fonte conta uma vez, a mais forte dela) → decisão."""
best: dict[tuple[str, str], Evidence] = {}
for e in evidence:
if not e.gid or e.strength <= 0:
continue
key = (e.gid, e.source)
if key not in best or e.score() > best[key].score():
best[key] = e
by_game: dict[str, Candidate] = {}
for (gid, _), e in best.items():
cand = by_game.setdefault(gid, Candidate(gid, e.game))
cand.evidence.append(e)
for cand in by_game.values():
miss = 1.0
for e in cand.evidence:
miss *= 1.0 - e.score()
cand.score = 1.0 - miss
# O nome mostrado: o da fonte mais forte (categoria > tela > resto).
cand.game = max(cand.evidence, key=lambda e: (e.source == "platform", e.source == "screen", e.score())).game
ranked = sorted(by_game.values(), key=lambda c: c.score, reverse=True)
if not ranked or ranked[0].score < 0.15:
return Decision("unknown", None, ranked)
top = ranked[0]
second = ranked[1] if len(ranked) > 1 else None
if second and second.score >= PROBABLE_MIN and top.score - second.score < CLEAR_LEAD \
and any(s in STRONG_SOURCES for s in second.sources):
return Decision("conflict", top, ranked)
if len(top.sources) >= 2 and top.score >= AGREED_MIN:
return Decision("agreed", top, ranked)
if top.score >= PROBABLE_MIN:
return Decision("probable", top, ranked)
return Decision("unknown", None, ranked)