"""Emotes do chat: reconhecer, contar por canal e APRENDER quais indicam um bom momento. Por quê: chat pequeno (3–5 pessoas) e público que reage com emote em vez de texto ("kkkk") faziam a heurística não ver nada. Agora cada mensagem leva a lista de emotes, e cada canal tem um peso aprendido por emote. De onde vêm: - Twitch nativos: tag `emotes` do IRC (CAP twitch.tv/tags) com as posições na mensagem; - 7TV, BTTV e FFZ do canal + globais: APIs públicas por `room-id` (o id do canal vem nas tags do IRC); - emojis Unicode. Cada fonte externa é opcional: a que falhar (404, lenta) é ignorada e tentada de novo na próxima hora. Aprendizado (por canal, tabela `emotes`): - `uses`: quantas vezes apareceu (contagem simples, para o painel); - `weight`: sobe quando o emote aparece na reação de um corte aprovado/bem avaliado, desce quando o corte é rejeitado/descartado. Entra no peso da mensagem na pontuação do chat. """ from __future__ import annotations import logging import re import threading import time import httpx log = logging.getLogger("cenaforge_clipper.emotes") CATALOG_TTL_S = 3600 LEARN_UP, LEARN_DOWN = 0.3, 0.15 WEIGHT_MIN, WEIGHT_MAX = -1.0, 3.0 BASE_EMOTE_BONUS = 0.4 # mensagem com emote já é reação BONUS_MIN, BONUS_MAX = -0.5, 3.0 # Faixas comuns de emoji (pictogramas, símbolos, bandeiras, rostos). Não é exaustivo, só precisa pegar os de reação. EMOJI_RE = re.compile("[\U0001F300-\U0001FAFF\U00002600-\U000027BF\U0001F1E6-\U0001F1FF]") GLOBAL_URLS = { "7tv": "https://7tv.io/v3/emote-sets/global", "bttv": "https://api.betterttv.net/3/cached/emotes/global", "ffz": "https://api.frankerfacez.com/v1/set/global", } CHANNEL_URLS = { "7tv": "https://7tv.io/v3/users/twitch/{room}", "bttv": "https://api.betterttv.net/3/cached/users/twitch/{room}", "ffz": "https://api.frankerfacez.com/v1/room/id/{room}", } def parse_twitch_tag(tag_value: str, text: str) -> list[str]: """`emotes=25:0-4,12-16/1902:6-10` → nomes recortados do texto (posições em code points, como o str do Python).""" names: list[str] = [] if not tag_value: return names for part in tag_value.split("/"): if ":" not in part: continue _id, spans = part.split(":", 1) for span in spans.split(","): try: a, b = (int(x) for x in span.split("-")) except ValueError: continue if 0 <= a <= b < len(text): names.append(text[a: b + 1]) return names def _names_from(source: str, data) -> list[str]: if source == "7tv": emotes = data.get("emotes") or (data.get("emote_set") or {}).get("emotes") or [] return [e["name"] for e in emotes if isinstance(e, dict) and e.get("name")] if source == "bttv": items = data if isinstance(data, list) else (data.get("channelEmotes", []) + data.get("sharedEmotes", [])) return [e["code"] for e in items if isinstance(e, dict) and e.get("code")] if source == "ffz": return [e["name"] for s in (data.get("sets") or {}).values() for e in s.get("emoticons", []) if e.get("name")] return [] class EmoteCatalog: """Nomes de emotes de terceiros (globais + do canal), com cache de 1 h por canal.""" def __init__(self, fetch=None): self._fetch = fetch or self._http_json self._lock = threading.Lock() self._global: dict[str, str] = {} self._global_at = 0.0 self._channels: dict[str, tuple[float, dict[str, str]]] = {} @staticmethod def _http_json(url: str): response = httpx.get(url, timeout=20, headers={"User-Agent": "CenaForge-Clipador"}) if response.status_code != 200: return None return response.json() def _load(self, urls: dict[str, str]) -> dict[str, str]: found: dict[str, str] = {} for source, url in urls.items(): try: data = self._fetch(url) except Exception as exc: # noqa: BLE001 - fonte externa opcional log.info("emotes %s indisponível (%s)", source, type(exc).__name__) continue if data: for name in _names_from(source, data): found.setdefault(name, source) return found def cached(self, room_id: str | None) -> dict[str, str]: """O que já foi baixado, sem tocar na rede (usado na linha do chat, que não pode esperar API externa).""" with self._lock: merged = dict(self._global) if room_id and room_id in self._channels: merged.update(self._channels[room_id][1]) return merged def names(self, room_id: str | None) -> dict[str, str]: now = time.time() with self._lock: if now - self._global_at > CATALOG_TTL_S: self._global, self._global_at = self._load(GLOBAL_URLS), now merged = dict(self._global) if room_id: cached = self._channels.get(room_id) if not cached or now - cached[0] > CATALOG_TTL_S: cached = (now, self._load({k: v.format(room=room_id) for k, v in CHANNEL_URLS.items()})) self._channels[room_id] = cached merged.update(cached[1]) return merged def extract(text: str, twitch_emotes: list[str], catalog: dict[str, str]) -> list[tuple[str, str]]: """(nome, fonte) de cada emote da mensagem: nativos da Twitch, de terceiros (palavra exata) e emojis.""" out: list[tuple[str, str]] = [(name, "twitch") for name in twitch_emotes] seen = {name for name, _ in out} for token in text.split(): if token in catalog and token not in seen: out.append((token, catalog[token])) seen.add(token) for emoji in EMOJI_RE.findall(text): if emoji not in seen: out.append((emoji, "emoji")) seen.add(emoji) return out def message_bonus(emotes: list[str], weights: dict[str, float]) -> float: """Bônus de peso da mensagem pelos emotes: base por ter emote + pesos aprendidos do canal.""" if not emotes: return 0.0 learned = sum(max(WEIGHT_MIN, min(WEIGHT_MAX, weights.get(name, 0.0))) for name in set(emotes)) return max(BONUS_MIN, min(BONUS_MAX, BASE_EMOTE_BONUS + learned)) def learn_delta(positive: bool) -> float: return LEARN_UP if positive else -LEARN_DOWN