Files
MateuusandClaude Opus 5.5 44bb961d1a 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>
2026-11-18 05:08:57 -03:00

165 lines
7.3 KiB
Python
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""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)