"""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)