"""Motor do Clipador: grava, lê o chat, transcreve, escolhe os momentos, consulta o juiz e renderiza. Threads: - monitor: de tempos em tempos pergunta ao Streamlink se cada canal monitorado entrou ao vivo; - uma captura por sessão: streamlink → (bomba em Python) → ffmpeg segmentando em blocos .ts; - um leitor de chat por sessão ao vivo (chat.py); - análise: para cada bloco novo, volume por segundo + transcrição (serviço de voz, palavras com tempo); - cortes: pontua a linha do tempo, manda candidatos ao juiz e renderiza os aprovados, um por vez. Tempo: `t` = segundos da gravação (soma das durações dos blocos). O chat chega com o relógio de parede e é convertido pelo instante em que cada bloco terminou de chegar (`wall_end`); assim pausas do Streamlink (anúncio filtrado na Twitch) não desalinham chat e vídeo. """ from __future__ import annotations import csv import json import logging import re import shutil import subprocess import threading import time from dataclasses import dataclass, replace from datetime import datetime from pathlib import Path import httpx from . import capture as capture_quality from . import clip_delete, context_judge, layout, media, timeline from . import roles as roles_module from .chat import ChatReader from .config import REPO_ROOT, Settings from .db import Database, loads, now from .face import FaceService from .hashtags import build_caption, split_hashtags from .hashtags import compose as compose_hashtags from .intel import Intel from .judge import (Judge, JudgeError, analysis_block, build_context_prompt, build_prompt, build_timeline_prompt) from .scoring import ChatMessage, Params, Word, find_moments, overlaps from .sources import Source, parse_source from .speakers import SpeakerService, dump_words, parse_words from .subtitles import build_ass, phrases log = logging.getLogger("cenaforge_clipper") LIVE_WINDOW_S = 900 # ao vivo, pontua só os últimos 15 min (o que veio antes já foi decidido) # Orçamento de caracteres da linha do tempo JSON por papel (~4 caracteres por token). ANALYST_TIMELINE_CHARS = 9000 EDITOR_TIMELINE_CHARS = 7000 JUDGE_TIMELINE_CHARS = 6000 def rel(path: Path) -> str: return path.relative_to(REPO_ROOT).as_posix() # ---------------------------------------------------------------- serviço de voz # O serviço de voz (voice/app/stt.py, WHISPER_LANGUAGES) aceita "pt-BR", "en" e "es"; fonte e sessão usam o idioma do # público ("en-US", "es-419"). Tradução num ponto só, aqui na fronteira (medido 18/11/2026: "en-US" voltava 422). VOICE_LANGUAGES = {"pt-BR": "pt-BR", "en-US": "en", "en": "en", "es-419": "es", "es": "es"} def voice_language(code: str) -> str: return VOICE_LANGUAGES.get(code, code.split("-")[0] if code and not code.startswith("pt") else "pt-BR") class VoiceClient: def __init__(self, url: str | None, key: str | None, language: str): self.url, self.key, self.language = url, key, language @property def configured(self) -> bool: return bool(self.url and self.key) def healthy(self) -> bool: if not self.url: return False try: return httpx.get(f"{self.url}/health", timeout=3).status_code == 200 except httpx.HTTPError: return False def transcribe(self, wav: bytes, idempotency_key: str, language: str | None = None) -> list[Word]: """`language` = idioma da sessão (fonte gringa); vazio/None = o padrão do serviço (CLIPPER_LANGUAGE).""" if not self.configured: raise RuntimeError("serviço de voz não instalado") headers = { "X-Service-Key": self.key or "", "Content-Type": "audio/wav", "X-Language": voice_language(language or self.language), "X-Detail": "words", "X-Idempotency-Key": idempotency_key, } response = httpx.post(f"{self.url}/v1/transcribe", content=wav, headers=headers, timeout=180) deadline = time.monotonic() + 900 while response.status_code == 202 and time.monotonic() < deadline: pending = response.json() time.sleep(min(10.0, max(0.5, pending.get("retryAfterMs", 1000) / 1000))) response = httpx.get(f"{self.url}/v1/transcribe/jobs/{pending['jobRef']}", headers={"X-Service-Key": self.key or ""}, timeout=60) if response.status_code != 200: raise RuntimeError(f"voz respondeu {response.status_code}: {response.text[:160]}") words = [] for segment in response.json().get("segments", []): for w in segment.get("words", []): if w.get("text", "").strip(): words.append(Word(float(w["start"]), float(w["end"]), w["text"].strip())) return words # ---------------------------------------------------------------- captura de uma sessão class Capture: """streamlink → ffmpeg (blocos .ts + segments.csv). Para quando a live acaba, o VOD termina ou pedem stop().""" def __init__(self, engine: "Engine", session_id: int, source: Source, workdir: Path, start_idx: int = 0): self.engine, self.session_id, self.source, self.workdir = engine, session_id, source, workdir # Retomada (serviço reiniciou no meio da live): continua a numeração dos blocos da mesma sessão. O trecho # perdido durante o reinício não existe na gravação; o tempo `t` segue somando só o que foi gravado. self.start_idx = start_idx self.chat: ChatReader | None = None self._stop = threading.Event() self._procs: list[subprocess.Popen] = [] self.thread = threading.Thread(target=self._run, name=f"capture-{session_id}", daemon=True) def start(self) -> None: if self.source.kind == "live": self.chat = ChatReader(self.source.platform, self.source.channel, self._on_chat) self.chat.start() self.thread.start() def stop(self) -> None: self._stop.set() if self._procs: media_terminate(self._procs[0]) # streamlink: o ffmpeg recebe EOF e fecha o último bloco def _on_chat(self, batch: list[tuple[float, str, str, list[str]]]) -> None: key = self.source.channel_id if self.source.channel else "" self.engine.intel.ingest_chat(self.session_id, key, self.chat.room_id if self.chat else None, batch) def _run(self) -> None: s, db = self.engine.settings, self.engine.db self.workdir.mkdir(parents=True, exist_ok=True) # Cada execução tem seu CSV (o da execução anterior já foi lido e não pode ser relido do zero). csv_path = self.workdir / ("segments.csv" if self.start_idx == 0 else f"segments-{self.start_idx:05d}.csv") # Qualidade da configuração (padrão ← canal ← sessão), lida a cada início/retomada: `best` ou um teto. self.quality = self.engine.capture_quality(self.session_id) choice = capture_quality.stream_choice(self.quality, self.source.platform) log.info("captura da sessão %s: qualidade %s (streamlink %s)", self.session_id, self.quality, " ".join([*choice.options, choice.streams])) streamlink = subprocess.Popen( [s.streamlink or "streamlink", "--stdout", "--loglevel", "warning", "--retry-open", "3", *choice.args(self.source.url)], stdout=subprocess.PIPE, stderr=subprocess.PIPE, creationflags=media.NO_WINDOW, ) ffmpeg = subprocess.Popen( [s.ffmpeg or "ffmpeg", "-hide_banner", "-loglevel", "error", "-i", "pipe:0", "-map", "0:v:0", "-map", "0:a:0?", "-c", "copy", "-f", "segment", "-segment_time", str(s.segment_s), "-reset_timestamps", "1", "-segment_list", csv_path.name, "-segment_list_type", "csv", "-segment_start_number", str(self.start_idx), "seg_%05d.ts"], stdin=subprocess.PIPE, stderr=subprocess.PIPE, cwd=self.workdir, creationflags=media.NO_WINDOW, ) self._procs = [streamlink, ffmpeg] errors: list[str] = [] threading.Thread(target=_drain, args=(streamlink.stderr, errors), daemon=True).start() threading.Thread(target=_drain, args=(ffmpeg.stderr, errors), daemon=True).start() pump = threading.Thread(target=self._pump, args=(streamlink, ffmpeg), daemon=True) pump.start() seen = 0 db.run("UPDATE sessions SET status = 'recording' WHERE id = ?", self.session_id) while pump.is_alive() or ffmpeg.poll() is None: seen = self._collect(csv_path, seen) if self.chat: db.run("UPDATE sessions SET chat_status = ? WHERE id = ?", self.chat.status, self.session_id) time.sleep(1.0) if not pump.is_alive() and ffmpeg.poll() is None: try: ffmpeg.wait(timeout=30) except subprocess.TimeoutExpired: media_terminate(ffmpeg) self._collect(csv_path, seen) if self.chat: self.chat.stop() stopped = self._stop.is_set() count = db.get("SELECT COUNT(*) AS n FROM segments WHERE session_id = ? AND idx >= ?", self.session_id, self.start_idx)["n"] if self.source.kind == "live" and not stopped and (count > 0 or self.start_idx > 0): # O Streamlink parou sem ninguém pedir (queda de rede, servidor, fim da live…). Não é prova de que a live # acabou: a sessão fica 'interrupted' e o motor checa de novo, com espera crescente, antes de processar. log.info("captura da sessão %s parou sozinha (%d blocos nesta execução): %s", self.session_id, count, " | ".join(errors[-3:])[:300] or "sem mensagem") self.engine.capture_dropped(self.session_id, got_video=count > 0) return if count == 0 and not stopped: message = " | ".join(errors[-3:]) or "o Streamlink não entregou vídeo (canal offline ou link inválido)" db.run("UPDATE sessions SET status = 'error', error = ?, ended_at = ?, chat_status = 'off' WHERE id = ?", message[:500], now(), self.session_id) else: db.run("UPDATE sessions SET status = 'processing', ended_at = ?, chat_status = 'off' WHERE id = ?", now(), self.session_id) self.engine.capture_finished(self.session_id) def _pump(self, src: subprocess.Popen, dst: subprocess.Popen) -> None: try: while True: chunk = src.stdout.read(256 * 1024) # type: ignore[union-attr] if not chunk: break dst.stdin.write(chunk) # type: ignore[union-attr] except (BrokenPipeError, OSError, ValueError): pass finally: try: dst.stdin.close() # type: ignore[union-attr] except OSError: pass media_terminate(src) def _collect(self, csv_path: Path, seen: int) -> int: """Blocos fechados pelo ffmpeg (uma linha do CSV por bloco completo).""" if not csv_path.is_file(): return seen with csv_path.open(newline="", encoding="utf-8") as fh: rows = list(csv.reader(fh)) db = self.engine.db for row in rows[seen:]: if len(row) < 3: break file, start, end = row[0], float(row[1]), float(row[2]) last = db.get("SELECT end_s FROM segments WHERE session_id = ? ORDER BY idx DESC LIMIT 1", self.session_id) t0 = last["end_s"] if last else 0.0 t1 = t0 + max(0.0, end - start) db.run("INSERT OR IGNORE INTO segments (session_id, idx, file, start_s, end_s, wall_end) VALUES (?, ?, ?, ?, ?, ?)", self.session_id, self.start_idx + seen, rel(self.workdir / file), round(t0, 3), round(t1, 3), time.time()) db.run("UPDATE sessions SET duration_s = ? WHERE id = ?", round(t1, 3), self.session_id) if seen == 0: self._record_quality(self.workdir / file) seen += 1 self.engine.wake_analysis.set() return seen def _record_quality(self, file: Path) -> None: """Resolução/qps/codec reais do 1º bloco desta execução → `sessions.capture_json` (o painel mostra "gravando em 2560×1440 · 60 qps"). Falha do ffprobe não atrapalha a gravação.""" ffprobe = self.engine.settings.ffprobe if not ffprobe: return try: probed = capture_quality.probe_block(ffprobe, file) except (media.MediaError, OSError) as exc: log.warning("sessão %s: não deu para ler a resolução gravada (%s)", self.session_id, exc) return db = self.engine.db row = db.get("SELECT capture_json FROM sessions WHERE id = ?", self.session_id) info = capture_quality.record_run(loads(row["capture_json"] if row else None, None), getattr(self, "quality", capture_quality.DEFAULT_QUALITY), self.start_idx, probed, now()) db.run("UPDATE sessions SET capture_json = ? WHERE id = ?", json.dumps(info), self.session_id) log.info("sessão %s gravando em %s (%s, %s kbps; pedido: %s)", self.session_id, capture_quality.label(info), info.get("codec") or "?", info.get("kbps") or "?", info["quality"]) def _drain(stream, sink: list[str]) -> None: for line in iter(stream.readline, b""): text = line.decode("utf-8", errors="replace").strip() if text: sink.append(text) del sink[:-20] log.info("captura: %s", text[:200]) def media_terminate(proc: subprocess.Popen) -> None: if proc.poll() is None: try: proc.terminate() proc.wait(timeout=10) except (subprocess.TimeoutExpired, OSError): proc.kill() # ---------------------------------------------------------------- checagem de live @dataclass(frozen=True) class LiveCheck: """Resultado de `streamlink --json`: `live`, `offline` (o Streamlink disse que não há stream) ou `unknown` (não deu para checar: timeout, erro, JSON inválido). `unknown` NÃO é prova de que a live acabou.""" state: str meta: dict | None = None reason: str = "" @property def live(self) -> bool: return self.state == "live" # Mensagens do Streamlink que significam "canal sem transmissão" (e não falha da checagem). OFFLINE_RE = re.compile(r"no playable streams|no streams found|is offline|not currently live|offline", re.I) # Retomada de live (subida do serviço ou captura que caiu): espera antes de cada checagem (≈ 5,7 min no total). RESUME_DELAYS_S = (0.0, 10.0, 20.0, 40.0, 60.0, 90.0, 120.0) OFFLINE_CONFIRMATIONS = 2 # "offline" seguido este tanto de vezes encerra antes de esgotar as tentativas MAX_EMPTY_RESUMES = 3 # retomadas seguidas sem nenhum bloco novo: desiste (a live "existe" mas não entrega vídeo) # ---------------------------------------------------------------- mesmo momento (cortes duplicados) # Bug medido (16/11/2026, sessão 3): o candidato fica em volta do pico (1149 s), o juiz recua o corte para 1012–1100 # — em cima do corte 9, já pronto — e, na passada seguinte, o candidato do MESMO pico já não sobrepunha o corte # recuado e era criado de novo (cortes 42, 47, 49, 51, 52). Agora: o pico e a janela original do candidato também # contam, e o trecho final é conferido de novo depois do juiz. SAME_PEAK_S = 10.0 # picos a até isto um do outro = o mesmo momento SAME_MOMENT_OVERLAP = 0.6 # trechos finais que se cobrem em ≥ 60 % do mais curto = o mesmo momento KEPT_STATUSES = ("pending", "rendering", "ready", "approved", "published") # Momento que você REJEITOU também não volta como corte novo (o candidato já era barrado em qualquer estado; agora o # trecho final depois do juiz também é). Medido (17/11/2026): o juiz recuou o 64 (pico 8909) para 8790–8858, a cena # do 61 (8794–8838); o 61 foi rejeitado 2 min depois. O descartado pela IA continua NÃO vetando o trecho final. VETO_STATUSES = KEPT_STATUSES + ("rejected",) ORPHAN_RENDER_S = 300.0 # 'rendering' sem ninguém renderizando há mais que isto volta para a fila MAX_RENDER_ATTEMPTS = 3 # depois disso o corte órfão vira 'error' def candidate_window(clip: dict) -> tuple[float, float]: """Janela original do candidato (antes do juiz mexer); cortes antigos não guardavam: vale o trecho atual.""" reasons = loads(clip.get("reasons_json"), {}) if isinstance(clip.get("reasons_json"), str) else (clip.get("reasons") or {}) try: return float(reasons["candidateStartS"]), float(reasons["candidateEndS"]) except (KeyError, TypeError, ValueError): return float(clip["start_s"]), float(clip["end_s"]) def same_moment(a: dict, b: dict) -> bool: """Dois cortes são o mesmo momento: picos a até `SAME_PEAK_S`, ou trechos finais que se cobrem em `SAME_MOMENT_OVERLAP` do mais curto.""" if a.get("peak_s") is not None and b.get("peak_s") is not None and abs(a["peak_s"] - b["peak_s"]) <= SAME_PEAK_S: return True inter = min(a["end_s"], b["end_s"]) - max(a["start_s"], b["start_s"]) shorter = min(a["end_s"] - a["start_s"], b["end_s"] - b["start_s"]) return shorter > 0 and inter / shorter >= SAME_MOMENT_OVERLAP def duplicate_of(clip: dict, others: list[dict]) -> dict | None: """Primeiro corte de `others` (outro id, mesma sessão) que é o mesmo momento de `clip`.""" return next((o for o in others if o["id"] != clip["id"] and o["session_id"] == clip["session_id"] and same_moment(clip, o)), None) # ---------------------------------------------------------------- motor class Engine: def __init__(self, settings: Settings, db: Database, judge: Judge | None = None, voice: VoiceClient | None = None): self.settings, self.db = settings, db saved = {r["key"]: r["value"] for r in db.all("SELECT key, value FROM settings")} if judge is None: # Equipe de IA: papéis gravados em `judge.roles`; sem eles, a configuração antiga vira a de todos os papéis # (migração automática, gravada já na subida para ficar explícita no banco). roles = roles_module.from_settings(saved, settings.judge_provider, settings.judge_model) judge = Judge(saved.get("judge_provider", settings.judge_provider), saved.get("judge_model", settings.judge_model), settings.data_dir / "judge", saved.get("judge_analyst_model", ""), roles=roles) if roles_module.SETTINGS_KEY not in saved: db.run("INSERT INTO settings (key, value) VALUES (?, ?) ON CONFLICT (key) DO UPDATE SET value = excluded.value", roles_module.SETTINGS_KEY, json.dumps(judge.roles, ensure_ascii=False)) self.judge = judge self.judge.meter = self.record_ai_call # medição por chamada (F0): tabela ai_calls self.min_score = float(saved.get("judge_min_score", settings.judge_min_score)) self.voice = voice or VoiceClient(settings.voice_url, settings.voice_key, settings.language) self.params = Params() self.captures: dict[int, Capture] = {} self.lock = threading.RLock() self.stop_event = threading.Event() self.wake_analysis = threading.Event() self.wake_clips = threading.Event() self._encoder: list[str] | None = None self._threads: list[threading.Thread] = [] self.intel = Intel(self) self.face = FaceService(self) # rastreio do rosto do streamer (face.py); não carrega modelo aqui self.speakers = SpeakerService(self) # quem fala cada palavra (speakers.py); modelo de voz só no 1º bloco self.resume_delays: tuple[float, ...] = RESUME_DELAYS_S # os testes encurtam self._recovering: set[int] = set() # sessões com uma thread de retomada em andamento self._rendering: set[int] = set() # cortes que ESTE processo está renderizando agora self._render_attempts: dict[int, int] = {} # vezes que um corte ficou órfão em 'rendering' self._empty_resumes: dict[int, int] = {} # ---------- ciclo de vida def start(self) -> None: for name, target in (("monitor", self._monitor_loop), ("analysis", self._analysis_loop), ("clips", self._clip_loop), ("context", self._context_loop), ("scan", self._scan_loop), ("face", self._face_loop)): thread = threading.Thread(target=self._guard, args=(name, target), name=name, daemon=True) thread.start() self._threads.append(thread) if getattr(self.db, "interrupted_on_start", None): threading.Thread(target=self.resume_interrupted, args=(list(self.db.interrupted_on_start),), name="resume", daemon=True).start() def resume_interrupted(self, session_ids: list[int]) -> None: """Na subida: lives que estavam gravando quando o serviço caiu voltam a gravar se ainda estão no ar; senão, o que foi gravado segue para o processamento final (varredura, juízes, render). Bug medido (16/11/2026, sessão 3): a 1ª checagem logo depois do reinício falhou e a live, que estava no ar, foi direto para o processamento. Agora cada sessão tenta de novo com espera crescente (`keep_live`).""" for session_id in session_ids: if self.stop_event.is_set(): return self.keep_live(session_id, "reinício do serviço") def keep_live(self, session_id: int, why: str) -> bool: """Tenta voltar a gravar uma live `interrupted`, checando com espera crescente (`resume_delays`). Enquanto tenta, a sessão continua `interrupted` (o painel mostra "Retomar gravação"). Desiste — e processa o que foi gravado — só depois de esgotar as tentativas ou de ver "offline" `OFFLINE_CONFIRMATIONS` vezes seguidas. Se você retomar, processar ou apagar a sessão no meio, a thread para sem mexer em nada. Devolve True se retomou.""" with self.lock: if session_id in self._recovering: return False # outra thread já está cuidando desta sessão self._recovering.add(session_id) try: offline_streak = 0 last = LiveCheck("unknown", reason="nenhuma checagem") for attempt, delay in enumerate(self.resume_delays, start=1): if delay and self.stop_event.wait(delay): return False session = self.db.get("SELECT status, url, kind FROM sessions WHERE id = ?", session_id) if not session or session["status"] != "interrupted" or session["kind"] != "live": log.info("sessão %s: retomada automática cancelada (estado %s)", session_id, session["status"] if session else "apagada") return False last = self.live_check(session["url"]) if last.live: try: if self.resume_session(session_id, checked=True, only_if_status="interrupted"): log.info("sessão %s retomada (%s; tentativa %d)", session_id, why, attempt) return True return False # você mexeu na sessão no meio: não briga except RuntimeError as exc: log.warning("sessão %s: retomada falhou (%s; tentativa %d)", session_id, exc, attempt) offline_streak = 0 continue offline_streak = offline_streak + 1 if last.state == "offline" else 0 log.info("sessão %s: live %s (%s; tentativa %d de %d)", session_id, "offline" if last.state == "offline" else "não checada", last.reason or "-", attempt, len(self.resume_delays)) if offline_streak >= OFFLINE_CONFIRMATIONS: break log.info("sessão %s não retomada (%s; última checagem: %s %s): processando o que foi gravado", session_id, why, last.state, last.reason) self.db.run("UPDATE sessions SET status = 'processing', chat_status = 'off', ended_at = COALESCE(ended_at, ?) " "WHERE id = ? AND status = 'interrupted'", now(), session_id) self.wake_analysis.set() self.wake_clips.set() return False finally: with self.lock: self._recovering.discard(session_id) def capture_dropped(self, session_id: int, got_video: bool) -> None: """A captura de uma live parou sem ninguém pedir. A sessão fica `interrupted` e uma thread tenta retomar (`keep_live`); retomadas seguidas que não trazem nenhum bloco novo param depois de `MAX_EMPTY_RESUMES`.""" empty = 0 if got_video else self._empty_resumes.get(session_id, 0) + 1 self._empty_resumes[session_id] = empty self.db.run("UPDATE sessions SET status = 'interrupted', ended_at = ?, chat_status = 'off' WHERE id = ?", now(), session_id) self.capture_finished(session_id) if empty >= MAX_EMPTY_RESUMES or self.stop_event.is_set(): self.db.run("UPDATE sessions SET status = 'processing', error = ? WHERE id = ? AND status = 'interrupted'", "não deu para retomar: a live não entrega vídeo", session_id) self._empty_resumes.pop(session_id, None) return threading.Thread(target=self.keep_live, args=(session_id, "captura caiu"), name=f"resume-{session_id}", daemon=True).start() def resume_session(self, session_id: int, *, checked: bool = False, only_if_status: str | None = None) -> bool: """Volta a gravar uma live interrompida/parada NA MESMA sessão (blocos continuam a numeração). `checked` = quem chama já confirmou que está ao vivo; `only_if_status` = só retoma se a sessão ainda estiver nesse estado (a retomada automática não atropela o que você fez no painel). Devolve True se iniciou.""" session = self.db.get("SELECT * FROM sessions WHERE id = ?", session_id) if not session: raise RuntimeError("sessão não encontrada") if session["kind"] != "live": raise RuntimeError("só dá para retomar live (VOD: crie uma sessão nova com o link)") with self.lock: if session_id in self.captures: return False # já está gravando if not checked and not self.check_live(session["url"])[0]: raise RuntimeError("o canal não está ao vivo agora (ou a checagem falhou; veja o log do Clipador)") source = parse_source(session["url"]) last = self.db.get("SELECT MAX(idx) AS n FROM segments WHERE session_id = ?", session_id)["n"] with self.lock: if session_id in self.captures: return False if only_if_status: current = self.db.get("SELECT status FROM sessions WHERE id = ?", session_id) if not current or current["status"] != only_if_status: return False self.db.run("UPDATE sessions SET status = 'starting', ended_at = NULL, error = NULL WHERE id = ?", session_id) capture = Capture(self, session_id, source, REPO_ROOT / session["dir"], start_idx=(last + 1) if last is not None else 0) self.captures[session_id] = capture if session["channel_id"] and not only_if_status: # Você retomou pelo painel: a fonte volta a ser monitorada (a retomada automática não mexe na pausa). self.clear_monitor_pause(session["channel_id"]) capture.start() return True def finish_session(self, session_id: int) -> None: """Encerra a gravação de vez e processa o que existe (passada final, varredura do resto, juízes, render).""" with self.lock: capture = self.captures.get(session_id) if capture: capture.stop() # a captura, ao terminar, já põe a sessão em 'processing' return self.db.run("UPDATE sessions SET status = 'processing', chat_status = 'off' WHERE id = ? AND status IN " "('interrupted', 'stopped', 'done', 'error')", session_id) self.wake_analysis.set() self.wake_clips.set() def shutdown(self) -> None: self.stop_event.set() self.wake_analysis.set() self.wake_clips.set() with self.lock: captures = list(self.captures.values()) for capture in captures: capture.stop() for capture in captures: capture.thread.join(timeout=20) def _guard(self, name: str, target) -> None: while not self.stop_event.is_set(): try: target() return except Exception: # noqa: BLE001 - uma falha não derruba o serviço: registra e reinicia o laço log.exception("laço %s falhou; reiniciando em 10 s", name) self.stop_event.wait(10) # ---------- juiz (configurável pelo painel, sem reiniciar) def judge_config(self, full: bool = False) -> dict: """Configuração da Equipe de IA. `full` (GET /v1/judge) acrescenta as instruções padrão de cada papel (texto grande, só leitura no painel) e os nomes das checagens do juiz.""" out = self.judge.describe() | {"minScore": self.min_score, "options": dict(self.intel.opts), "lastScanError": self.intel.last_scan_error} if isinstance(out.get("roles"), dict) and "scan" in out["roles"]: out["roles"]["scan"]["enabled"] = bool(self.intel.opts.get("scanEnabled", True)) # liga/desliga = varredura if full: out["roleDefaults"] = self.judge.default_instructions() out["checks"] = [{"id": c, "label": roles_module.CHECK_NAMES[c]} for c in roles_module.CHECKS] return out def set_judge_config(self, provider: str, model: str, min_score: float, analyst_model: str | None = None, roles: dict | None = None) -> dict: if not 0 <= min_score <= 10: raise JudgeError("a nota mínima vai de 0 a 10") self.judge.configure(provider, model, analyst_model, roles) scan = (roles or {}).get("scan") if isinstance(roles, dict) else None if isinstance(scan, dict) and isinstance(scan.get("enabled"), bool): self.intel.set_options({"scanEnabled": scan["enabled"]}) # o cartão da varredura liga/desliga a varredura self.min_score = float(min_score) rows = [("judge_provider", self.judge.provider), ("judge_model", self.judge.model), ("judge_min_score", str(self.min_score)), ("judge_analyst_model", self.judge.analyst_model), (roles_module.SETTINGS_KEY, json.dumps(self.judge.roles, ensure_ascii=False))] self.db.many("INSERT INTO settings (key, value) VALUES (?, ?) ON CONFLICT (key) DO UPDATE SET value = excluded.value", rows) return self.judge_config(full=True) def record_ai_call(self, record: dict) -> None: """Uma linha em `ai_calls` por tentativa de chamada de IA (medição F0; relatório em GET /v1/judge/report).""" self.db.run( "INSERT INTO ai_calls (at, role, purpose, provider, model, ok, error, ms, system_chars, prompt_chars, images," " image_bytes, tokens_in, tokens_out, tokens_cached, session_id, clip_id, mode)" " VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", now(), record.get("role", ""), record.get("purpose", ""), record.get("provider", ""), record.get("model", ""), int(bool(record.get("ok"))), record.get("error"), record.get("ms"), record.get("systemChars"), record.get("promptChars"), record.get("images"), record.get("imageBytes"), record.get("tokensIn"), record.get("tokensOut"), record.get("tokensCached"), record.get("session_id"), record.get("clip_id"), record.get("mode")) # ---------- sessões def start_session(self, url: str, channel_id: str | None = None, language: str | None = None) -> int: """Começa a gravar (live) ou baixar (VOD). `language` = idioma falado; vazio herda o da fonte ('' = padrão). Gravar à mão uma fonte com o monitor pausado religa o monitor (você ligou de propósito).""" source = parse_source(url) if not self.settings.streamlink or not self.settings.ffmpeg: raise RuntimeError("Streamlink ou FFmpeg não encontrados: rode o setup.bat.") with self.lock: active = self.db.get("SELECT id FROM sessions WHERE url = ? AND status IN ('starting', 'recording')", source.url) if active: return active["id"] channel = self.db.get("SELECT language FROM channels WHERE id = ?", channel_id) if channel_id else None cur = self.db.run( "INSERT INTO sessions (channel_id, platform, kind, url, status, dir, started_at, language)" " VALUES (?, ?, ?, ?, 'starting', '', ?, ?)", channel_id, source.platform, source.kind, source.url, now(), (language or (channel or {}).get("language") or "").strip()) session_id = int(cur.lastrowid) if channel_id: self.clear_monitor_pause(channel_id) workdir = self.settings.data_dir / "sessions" / str(session_id) self.db.run("UPDATE sessions SET dir = ? WHERE id = ?", rel(workdir), session_id) capture = Capture(self, session_id, source, workdir) self.captures[session_id] = capture capture.start() if source.kind == "live": # Título da live (contexto para o juiz e para a lista). Em thread: o Streamlink leva alguns segundos. threading.Thread(target=self._fill_title, args=(session_id, source.url), daemon=True).start() return session_id def capture_quality(self, session_id: int) -> str: """`capture.quality` efetiva da sessão (padrão ← canal ← sessão).""" session = self.db.get("SELECT * FROM sessions WHERE id = ?", session_id) if not session: return capture_quality.DEFAULT_QUALITY return capture_quality.normalize_quality(self.intel.settings_for(session)["capture"].get("quality")) def _fill_title(self, session_id: int, url: str) -> None: """Título e jogo (categoria da plataforma) logo no início: contexto para a IA desde o primeiro corte.""" session = self.db.get("SELECT * FROM sessions WHERE id = ?", session_id) if session: self.intel.check_game(session, force=True) def stop_session(self, session_id: int, *, pause_monitor: bool = True) -> None: """Para a gravação. `pause_monitor` (padrão): a fonte monitorada fica com o monitor PAUSADO — senão, 60 s depois o monitor abriria uma sessão nova, porque a live continua no ar (reclamação do dono, 18/11/2026). A queda de live (captura cai sozinha) não passa por aqui e continua retomando na mesma sessão (`keep_live`).""" with self.lock: capture = self.captures.get(session_id) if capture: self.db.run("UPDATE sessions SET status = 'stopped' WHERE id = ? AND status IN ('starting', 'recording')", session_id) capture.stop() if pause_monitor: session = self.db.get("SELECT channel_id FROM sessions WHERE id = ?", session_id) if session and session["channel_id"]: changed = self.db.run("UPDATE channels SET monitor_paused_at = ?, monitor_paused_session = ? WHERE id = ? AND monitor = 1", now(), session_id, session["channel_id"]).rowcount if changed: log.info("fonte %s: monitor pausado (você parou a sessão %s)", session["channel_id"], session_id) def clear_monitor_pause(self, channel_id: str) -> None: """Religa o monitor da fonte (PATCH monitor=true, gravar pelo link ou retomar uma sessão dela).""" if self.db.run("UPDATE channels SET monitor_paused_at = NULL, monitor_paused_session = NULL WHERE id = ? AND monitor_paused_at IS NOT NULL", channel_id).rowcount: log.info("fonte %s: monitor religado", channel_id) def capture_finished(self, session_id: int) -> None: with self.lock: self.captures.pop(session_id, None) self.wake_analysis.set() self.wake_clips.set() def chat_status(self, session_id: int) -> dict | None: with self.lock: capture = self.captures.get(session_id) if capture and capture.chat: return {"status": capture.chat.status, "received": capture.chat.received} return None # ---------- monitor de canais def _monitor_loop(self) -> None: while not self.stop_event.is_set(): self.monitor_once() self.stop_event.wait(self.settings.poll_s) def monitor_once(self) -> list[int]: """Uma passada do monitor: checa cada fonte monitorada (e não pausada) sem sessão ativa e grava as que estão ao vivo. Devolve os ids das sessões iniciadas (os testes chamam direto).""" started: list[int] = [] for channel in self.db.all("SELECT * FROM channels WHERE monitor = 1"): if self.stop_event.is_set(): break if channel.get("monitor_paused_at"): log.debug("fonte %s: monitor pausado (sessão %s parada à mão), pulando", channel["id"], channel.get("monitor_paused_session")) continue busy = self.db.get("SELECT id FROM sessions WHERE channel_id = ? AND status IN ('starting', 'recording')", channel["id"]) if busy: continue live, title = self.check_live(channel["url"]) self.db.run("UPDATE channels SET last_check_at = ?, last_status = ? WHERE id = ?", now(), "ao vivo" if live else "offline", channel["id"]) if live: log.info("canal %s ao vivo: iniciando gravação", channel["id"]) try: session_id = self.start_session(channel["url"], channel["id"]) self.db.run("UPDATE sessions SET title = ? WHERE id = ?", title[:200], session_id) started.append(session_id) except Exception as exc: # noqa: BLE001 log.warning("canal %s: não iniciou (%s)", channel["id"], exc) return started def live_check(self, url: str) -> LiveCheck: """Streamlink --json, separando "offline" de "não deu para checar". Falha de checagem vai para o log com o motivo e o fim do stderr (antes era engolida e parecia "offline").""" if not self.settings.streamlink: return LiveCheck("unknown", reason="Streamlink não encontrado") try: out = subprocess.run([self.settings.streamlink, "--json", url], capture_output=True, timeout=60, creationflags=media.NO_WINDOW) except subprocess.TimeoutExpired: result = LiveCheck("unknown", reason="streamlink --json passou de 60 s") except OSError as exc: result = LiveCheck("unknown", reason=f"streamlink não rodou: {exc}") else: stdout = out.stdout.decode("utf-8", errors="replace").strip() stderr = " | ".join(out.stderr.decode("utf-8", errors="replace").strip().splitlines()[-3:])[:300] try: data = json.loads(stdout or "{}") except json.JSONDecodeError: data = None if not isinstance(data, dict): result = LiveCheck("unknown", reason=f"JSON inválido (código {out.returncode}): {stdout[:120]} {stderr}".strip()) elif data.get("streams"): meta = data.get("metadata") or {} return LiveCheck("live", {k: str(meta.get(k) or "") for k in ("title", "category", "author")}) elif OFFLINE_RE.search(str(data.get("error") or "")) or (out.returncode == 0 and "streams" in data): return LiveCheck("offline", reason=str(data.get("error") or "sem streams")[:200]) else: result = LiveCheck("unknown", reason=f"código {out.returncode}: {str(data.get('error') or '')[:150]} {stderr}".strip()) log.warning("checagem da live %s falhou: %s", url, result.reason) return result def check_meta(self, url: str) -> dict | None: """{title, category, author} se ao vivo (category = jogo na Twitch/Kick); None se offline OU se a checagem falhou — quem precisa diferenciar usa `live_check`.""" result = self.live_check(url) return result.meta if result.live else None def check_live(self, url: str) -> tuple[bool, str]: meta = self.check_meta(url) return (True, meta["title"]) if meta else (False, "") # ---------- contexto (jogo, webcam, catálogo de emotes) e varredura da IA def _context_loop(self) -> None: while not self.stop_event.is_set(): for session in self.db.all("SELECT * FROM sessions WHERE status IN ('recording', 'processing')"): if self.stop_event.is_set(): break try: self.intel.check_game(session) self.intel.maybe_detect_cam(session) except Exception as exc: # noqa: BLE001 - contexto é melhoria: falha não para a gravação log.warning("contexto da sessão %s: %s", session["id"], exc) try: self.intel.research_pending() except Exception as exc: # noqa: BLE001 log.warning("pesquisa de jogo falhou: %s", exc) self.stop_event.wait(30) def _scan_loop(self) -> None: while not self.stop_event.is_set(): worked = False for session in self.db.all("SELECT * FROM sessions WHERE status IN ('recording', 'processing', 'stopped')"): if self.stop_event.is_set(): break try: created = self.intel.scan_session(session) # None = nenhuma janela pronta if created: self.wake_clips.set() worked = worked or created is not None except Exception as exc: # noqa: BLE001 log.warning("varredura da sessão %s: %s", session["id"], exc) self.stop_event.wait(2 if worked else 20) def _face_loop(self) -> None: """Thread própria: rastreia o rosto bloco a bloco (CPU), sem atrasar a transcrição nem os cortes.""" self.face.run_forever(self.stop_event) # ---------- utilidades de arquivo/quadro (usadas pela inteligência) @staticmethod def repo_path(relative: str) -> Path: return REPO_ROOT / relative @staticmethod def rel(path: Path) -> str: return rel(path) def grab_frame(self, segments: list[tuple[Path, float, float]], t: float, out_file: Path, width: int = 768) -> Path: return media.grab_frame(self.settings.ffmpeg or "ffmpeg", segments, t, out_file, width) # ---------- análise dos blocos (volume + transcrição) def _analysis_loop(self) -> None: while not self.stop_event.is_set(): pending = self.db.all("SELECT * FROM segments WHERE analyzed = 0 AND deleted = 0 ORDER BY session_id, idx LIMIT 5") for segment in pending: if self.stop_event.is_set(): break self.analyze_segment(segment) if pending: self.wake_clips.set() else: self.wake_analysis.wait(5) self.wake_analysis.clear() def analyze_segment(self, segment: dict) -> None: file = REPO_ROOT / segment["file"] loudness: list = [] words: list[Word] = [] error = None try: pcm = media.decode_pcm(self.settings.ffmpeg or "ffmpeg", [file]) loudness = media.loudness_per_second(pcm) try: owner = self.db.get("SELECT language FROM sessions WHERE id = ?", segment["session_id"]) rel_words = self.voice.transcribe(media.to_wav(pcm), f"clipper-{segment['session_id']}-{segment['idx']}", language=(owner or {}).get("language") or None) words = [Word(round(w.start + segment["start_s"], 3), round(w.end + segment["start_s"], 3), w.word) for w in rel_words] except Exception as exc: # noqa: BLE001 - sem voz o corte segue pelo chat error = str(exc)[:300] if words: try: # Impressão de voz de cada trecho de fala (doc/clipador/FALANTES.md): ~0,2 s de CPU por bloco. self.speakers.index_block(segment, pcm, words) except Exception as exc: # noqa: BLE001 - sem falantes a legenda segue toda como do streamer self.speakers.last_error = str(exc)[:300] log.warning("falantes do bloco %s/%s: %s", segment["session_id"], segment["idx"], exc) except media.MediaError as exc: error = f"áudio: {exc}"[:300] self.db.run( "UPDATE segments SET analyzed = 1, loudness_json = ?, words_json = ?, transcript_error = ? WHERE session_id = ? AND idx = ?", json.dumps(loudness), dump_words(words), error, segment["session_id"], segment["idx"]) # ---------- linha do tempo de uma sessão def load_timeline(self, session_id: int, since_s: float = 0.0) -> dict: segments = self.db.all("SELECT * FROM segments WHERE session_id = ? ORDER BY idx", session_id) duration = segments[-1]["end_s"] if segments else 0.0 loudness: list[float | None] = [] words: list[Word] = [] analyzed_until = 0.0 for seg in segments: values = loads(seg["loudness_json"], []) length = int(round(seg["end_s"])) - int(round(seg["start_s"])) loudness.extend((values + [None] * length)[:length] if seg["analyzed"] else [None] * length) if seg["analyzed"]: if analyzed_until >= seg["start_s"] - 0.01: # só o trecho contínuo desde o início conta analyzed_until = seg["end_s"] words.extend(parse_words(seg["words_json"])) chat = [] if segments: first_wall = segments[0]["wall_end"] - (segments[0]["end_s"] - segments[0]["start_s"]) rows = self.db.all("SELECT wall, user, text, emotes FROM chat WHERE session_id = ? AND wall >= ? ORDER BY wall", session_id, first_wall + since_s - 60) session = self.db.get("SELECT url FROM sessions WHERE id = ?", session_id) key = self.intel.channel_key(session) if session else "" for r in rows: t = wall_to_t(r["wall"], segments) if t is None: continue emotes = tuple(loads(r["emotes"], [])) chat.append(ChatMessage(t, r["text"], r["user"], emotes, self.intel.bonus(list(emotes), key))) # Quem fala cada palavra (streamer × outra pessoa): juízes, tradução e legenda leem daqui. words = self.speakers.label(session_id, words) return {"segments": segments, "duration": duration, "loudness": loudness, "words": words, "chat": chat, "analyzedUntil": analyzed_until} def words_between(self, session_id: int, lo: float, hi: float) -> list[Word]: """Palavras dos blocos que tocam [lo, hi] (sem filtrar o tempo de cada palavra), já com o falante.""" rows = self.db.all("SELECT words_json FROM segments WHERE session_id = ? AND end_s > ? AND start_s < ? ORDER BY idx", session_id, lo, hi) return self.speakers.label(session_id, [w for r in rows for w in parse_words(r["words_json"])]) # ---------- cortes def _clip_loop(self) -> None: while not self.stop_event.is_set(): for session in self.db.all("SELECT * FROM sessions WHERE status IN ('recording', 'processing', 'stopped')"): if self.stop_event.is_set(): break self.find_new_clips(session) self.finish_if_done(session) self.judge_candidates() self.render_pending() self.prune() self.wake_clips.wait(15) self.wake_clips.clear() def find_new_clips(self, session: dict) -> int: if session["status"] == "recording" and session["kind"] == "vod": return 0 # VOD baixa mais rápido que o tempo real: decide tudo de uma vez quando terminar live = session["status"] == "recording" since = max(0.0, session["duration_s"] - LIVE_WINDOW_S) if live else 0.0 tl = self.load_timeline(session["id"], since) if tl["duration"] <= 0: return 0 offset = int(since) chat = [replace(m, t=m.t - offset) for m in tl["chat"] if m.t >= offset] words = [replace(w, start=w.start - offset, end=w.end - offset) for w in tl["words"] if w.start >= offset] face, face_until = self.face.for_scoring(session, offset, tl["duration"]) # None = sem câmera/rastreio # O candidato já nasce na duração da configuração do corte desta sessão (padrão 60–90 s). dur = self.intel.settings_for(session)["duration"] # mínimo + 1 s (pedido do dono, 17/11/2026: "se o mínimo é 60 tem que ser 60; sempre 1 s a mais") params = replace(self.params, min_s=layout.min_target({"duration": dur}), max_s=float(dur["maxS"])) moments = find_moments(tl["duration"] - offset, chat, tl["loudness"][offset:], words, params, live=live, face=face) existing = self.db.all("SELECT id, session_id, peak_s, start_s, end_s, reasons_json FROM clips WHERE session_id = ?", session["id"]) existing += clip_delete.marks(self.db, session["id"]) # corte que você apagou: o momento não volta created = 0 for m in moments: start, end, peak = m.start_s + offset, m.end_s + offset, m.peak_s + offset if "onsetS" in m.reasons: # a pontuação roda na janela recortada: volta ao tempo da gravação m.reasons["onsetS"] += offset for key in ("peakS", "onsetS", "endS"): if key in m.reasons.get("face", {}): m.reasons["face"][key] += offset # Só decide quando a fala do trecho (com folga) já foi transcrita. if min(end + 12, tl["duration"]) > tl["analyzedUntil"]: continue # E, com câmera e rastreio ligado, quando o rosto do trecho já foi lido (no máximo 2 blocos de atraso). if face is not None and self.face.must_wait(min(end + 12, tl["duration"]), face_until, tl["analyzedUntil"]): continue # O mesmo momento não vira corte duas vezes: trecho atual (o juiz pode ter recuado), janela ORIGINAL do # candidato e pico, contra cortes em qualquer estado (inclusive descartados). if any(overlaps(start, end, c["start_s"], c["end_s"]) or overlaps(start, end, *candidate_window(c)) or abs(peak - c["peak_s"]) <= SAME_PEAK_S for c in existing): continue reasons = {**m.reasons, "candidateStartS": round(start, 2), "candidateEndS": round(end, 2)} ts = now() cur = self.db.run( "INSERT INTO clips (session_id, peak_s, start_s, end_s, score, source, reasons_json, status, created_at, updated_at)" " VALUES (?, ?, ?, ?, ?, ?, ?, 'candidate', ?, ?)", session["id"], peak, start, end, m.score, m.source, json.dumps(reasons, ensure_ascii=False), ts, ts) existing.append({"id": cur.lastrowid, "session_id": session["id"], "peak_s": peak, "start_s": start, "end_s": end, "reasons_json": json.dumps(reasons)}) created += 1 return created def judge_candidates(self) -> None: for clip in self.db.all("SELECT * FROM clips WHERE status = 'candidate' ORDER BY id LIMIT 10"): if self.stop_event.is_set(): return self.judge_clip(clip) def judge_clip(self, clip: dict) -> None: session = self.db.get("SELECT * FROM sessions WHERE id = ?", clip["session_id"]) if session is None: return tl = self.load_timeline(clip["session_id"], max(0.0, clip["start_s"] - 300)) streamer = self.streamer_name(session) heuristic = loads(clip["reasons_json"], {}) dur = self.intel.settings_for(session)["duration"] transcript = " ".join(w.word for w in tl["words"] if clip["start_s"] <= w.start <= clip["end_s"]) fallback_title = heuristic.get("proposalTitle") or ( f"{streamer}: " + (" ".join(transcript.split()[:9]) or (heuristic.get("topMessages") or ["momento da live"])[0])) update = {"title": fallback_title[:100], "caption": "", "status": "pending", "judge": None, "start_s": clip["start_s"], "end_s": clip["end_s"]} if self.judge.enabled: # A ação vem antes do comentário: a IA vê `backtrackS` para trás (transcrição + frames) e pode recuar. lo = max(0.0, clip["start_s"] - dur["backtrackS"]) hi = min(tl["duration"], clip["end_s"] + 15) # Fonte em inglês: os juízes trabalham em inglês e devolvem também o português do painel (IDIOMAS.md). lang = self.intel.lang(session) # Linha do tempo JSON (novo) ou transcrição + chat + frames soltos (antigo, `timelineJson` desligado). use_timeline = bool(self.intel.opts.get("timelineJson", True)) analyst_on = self.judge.role_enabled("analyst") # Imagens como escolhido no analista (sem analista, o editor recebe as mesmas); formato antigo = soltos. image_mode = self.judge.roles["analyst"].get("images", "mosaic") if use_timeline else "frames" # Quadros espalhados de um pouco antes do candidato até o fim da reação: o analista vê a sequência. # 6 quadros; 8 quando o trecho passa de 80 s (cortes de 60–90 s), para não ficar > 20 s entre quadros. f_lo = max(lo, clip["start_s"] - 20) n_frames = 8 if hi - f_lo > 80 or image_mode == "mosaic" else 6 times = [f_lo + (hi - f_lo) * k / (n_frames - 1) for k in range(n_frames)] images, tiles, mosaic = self.intel.visual(session, times, f"clip{clip['id']}", image_mode) mode = ("timeline" if use_timeline else "legacy") + f"+{'mosaic' if mosaic else image_mode}" min_len = layout.min_target({"duration": dur}) with self.judge.scope(session_id=session["id"], clip_id=clip["id"], mode=mode): if use_timeline: prompt = build_timeline_prompt( streamer, session["platform"], clip["start_s"], clip["end_s"], clip["peak_s"], heuristic, context=self.intel.context(session, lean=True), timeline_text=self._timeline_text(session, tl, lo, hi), tiles=tiles, mosaic=mosaic, lo=lo, hi=hi, min_s=dur["minS"], max_s=dur["maxS"], lang=lang) else: prompt = build_prompt(streamer, session["platform"], clip["start_s"], clip["end_s"], clip["peak_s"], tl["words"], tl["chat"], heuristic, session["title"], context=self.intel.context(session), frames=list(zip(tiles, images)), backtrack_s=dur["backtrackS"], min_s=dur["minS"], max_s=dur["maxS"], face=self.face.summary(session, lo, hi), lang=lang) analysis = None try: # ANALISTA (vê a tela) diz o que aconteceu; o EDITOR decide e escreve a partir disso. if analyst_on: try: analysis = self.judge.analyze(prompt, images, lang=lang) except (JudgeError, json.JSONDecodeError, KeyError, ValueError) as exc: log.warning("analista falhou no corte %s: %s (editor segue sozinho)", clip["id"], exc) if analysis: # O que o analista viu em cada quadro vira o `v` da linha do tempo (editor e juiz reaproveitam). timeline.save_scene_lines(self, session["id"], "analyst", analysis.pop("lines", None), tiles) if use_timeline and analysis: # Editor: só texto, linha do tempo do trecho (da ação, se o analista a viu antes) até o fim. try: act = float(analysis.get("action_start_s")) except (TypeError, ValueError): act = clip["start_s"] e_lo = max(lo, min(clip["start_s"], act if lo <= act <= hi else clip["start_s"]) - 15) editor_prompt = build_timeline_prompt( streamer, session["platform"], clip["start_s"], clip["end_s"], clip["peak_s"], heuristic, context=self.intel.context(session, lean=True), timeline_text=self._timeline_text(session, tl, e_lo, hi, EDITOR_TIMELINE_CHARS), tiles=[], mosaic=False, lo=lo, hi=hi, min_s=dur["minS"], max_s=dur["maxS"], lang=lang, analysis=analysis) else: editor_prompt = prompt + ("\n\n" + analysis_block(analysis, lang) if analysis else "") # Sem análise, o editor recebe as imagens; com análise, só texto (mais barato, a tela já foi lida). verdict = self.judge.judge(editor_prompt, clip["start_s"], clip["end_s"], [] if analysis else images, lo=lo, hi=hi, min_s=min_len, max_s=dur["maxS"], lang=lang) # Corte manual: quem decidiu foi você; o juiz só escreve título e legenda (e não mexe no trecho). manual = clip["source"] == "manual" keep = manual or (verdict.keep and verdict.score >= self.min_score) if manual: verdict = verdict.__class__(**{**verdict.__dict__, "start_s": clip["start_s"], "end_s": clip["end_s"]}) update |= {"title": verdict.title or update["title"], "caption": verdict.caption, "hashtags": list(verdict.hashtags), "status": "pending" if keep else "discarded", "start_s": verdict.start_s, "end_s": verdict.end_s, "judge": {"model": verdict.model, "keep": verdict.keep, "score": verdict.score, "reason": verdict.reason, "analysis": analysis, # Fonte em inglês: título/legenda/motivo em português (só o painel lê). **({"pt": verdict.pt} if verdict.pt else {}), "analystModel": self.judge.role_model("analyst") if analysis else None}} if keep and self.judge.role_enabled("judge"): # JUIZ de contexto: o corte faz sentido sozinho? (só texto, só o que vai no corte final) self._context_check(session, clip, tl, update, verdict.score, analysis, lo, hi, min_len, float(dur["maxS"]), lang, manual) except (JudgeError, json.JSONDecodeError, KeyError, ValueError) as exc: # Falha do juiz não perde o momento: segue com a heurística e registra o motivo. update["judge"] = {"error": str(exc)[:300]} if update["status"] == "pending": # O juiz pode ter recuado o trecho para cima de um corte já mantido: confere de novo (todas as origens). kept = self.db.all(f"SELECT id, session_id, status, peak_s, start_s, end_s FROM clips WHERE session_id = ? " f"AND id != ? AND status IN {VETO_STATUSES}", clip["session_id"], clip["id"]) # Corte que você apagou quando estava num desses estados também veta (descartado pela IA apagado, não). kept += [m for m in clip_delete.marks(self.db, clip["session_id"]) if m["status"] in VETO_STATUSES] dup = duplicate_of({**clip, "start_s": update["start_s"], "end_s": update["end_s"]}, kept) if dup: judge_info = dict(update["judge"] or {}) judge_info["duplicateOf"] = dup["id"] if clip["source"] == "manual": # "cortar agora" nunca é bloqueado: só avisa judge_info["warning"] = f"mesmo momento do corte {dup['id']}" else: update["status"] = "discarded" why = ("que você apagou" if dup.get("deleted") else "que você rejeitou" if dup["status"] == "rejected" else "mesmo momento") judge_info["reason"] = (f"Duplicado do corte {dup['id']} ({why}). " + str(judge_info.get("reason") or "")).strip() log.info("corte %s descartado: mesmo momento do corte %s (%s)", clip["id"], dup["id"], dup["status"]) update["judge"] = judge_info # Legenda = texto da IA + hashtags (canal e jogo fixos, do perfil; momento, da IA) + crédito (app/hashtags.py). # Sem juiz (ou se ele falhou) ainda saem as do canal e do jogo. text, inline_tags = split_hashtags(update["caption"]) game_name, game_profile = self.intel.session_game(session) tags = compose_hashtags(streamer, game_name, game_profile, [*update.get("hashtags", []), *inline_tags]) caption = build_caption(text, tags, f"🎥 Créditos: {self.channel_link(session)}") transcript = " ".join(w.word for w in tl["words"] if update["start_s"] <= w.start <= update["end_s"]) self.db.run( "UPDATE clips SET title = ?, caption = ?, status = ?, judge_json = ?, start_s = ?, end_s = ?, transcript = ?, updated_at = ? WHERE id = ?", update["title"], caption, update["status"], json.dumps(update["judge"], ensure_ascii=False) if update["judge"] else None, update["start_s"], update["end_s"], transcript[:4000], now(), clip["id"]) if update["status"] == "pending": # Novo veredito: o projeto que a IA tinha gerado é refeito no render (o que você editou fica). self.db.run("DELETE FROM edits WHERE clip_id = ? AND origin = 'ai'", clip["id"]) # Fonte em inglês: a fala do corte em português para o painel (falha não segura o corte). with self.judge.scope(session_id=session["id"], clip_id=clip["id"]): self.translate_clip(clip["id"], update["start_s"], update["end_s"]) verdict_info = update["judge"] or {} if clip["source"] != "manual" and "score" in verdict_info: # Aprendizado fraco pela IA (o forte vem da sua aprovação/rejeição no painel). if update["status"] == "discarded": self.intel.learn_from_clip(clip, positive=False, factor=0.5) elif verdict_info["score"] >= 7: self.intel.learn_from_clip(clip, positive=True, factor=0.5) def _timeline_text(self, session: dict, tl: dict, lo: float, hi: float, budget: int = ANALYST_TIMELINE_CHARS, clip: tuple[float, float] | None = None, header: dict | None = None) -> str: """Linha do tempo JSON de [lo, hi] (app/timeline.py) com o que já existe: fala+falante, chat, rosto, volume e as frases de tela guardadas.""" ev = timeline.collect(self, session, tl, lo, hi) head = header or {"win": [int(lo), int(hi)], "src": self.intel.lang(session)} return timeline.build(ev, lo, hi, head, budget_chars=budget, clip=clip) def _context_check(self, session: dict, clip: dict, tl: dict, update: dict, score: float, analysis: dict | None, lo: float, hi: float, min_len: float, max_len: float, lang: str, manual: bool) -> None: """JUIZ de contexto sobre o corte que o editor manteve. O código decide pelas respostas (context_judge.decide): aprova (talvez com frase de contexto na tela), ajusta o trecho e confere UMA vez de novo, ou descarta com o motivo em português. Falha da IA aqui não muda a decisão do editor (só registra o erro).""" from .editor import pick_hook conf = self.judge.roles["judge"] game, profile = self.intel.session_game(session) summary = str((profile or {}).get("summary") or "") game_line = (summary.split(". ")[0] if summary else "")[:160] story = str((analysis or {}).get("what_happened") or "") opening, _ = pick_hook((analysis or {}).get("hook"), update["title"]) streamer = self.streamer_name(session) def ask(start: float, end: float) -> tuple[dict, str]: # O corte + 20 s antes e 15 s depois (marcados out=1): o juiz nota o começo ou o desfecho que ficaram de fora. t_lo = max(0.0, start - context_judge.OUT_BEFORE_S) t_hi = min(tl["duration"], end + context_judge.OUT_AFTER_S) text = self._timeline_text(session, tl, t_lo, t_hi, JUDGE_TIMELINE_CHARS, clip=(start, end), header={"clip": [int(start), int(end)], "src": lang}) prompt = build_context_prompt(streamer=streamer, game=game, game_line=game_line, start_s=start, end_s=end, title=update["title"], caption=update["caption"], opening=opening, story=story, timeline_text=text, lo=lo, hi=hi, min_s=min_len, max_s=max_len, lang=lang) result = self.judge.check_context(prompt, lang=lang) return result, self.judge.responder() judge_info = update["judge"] start, end = update["start_s"], update["end_s"] limits = {"lo": lo, "hi": hi, "min_s": min_len, "max_s": max_len, "conf": conf, "score": score, "min_score": self.min_score, "manual": manual} try: result, model = ask(start, end) decision = context_judge.decide(result, start_s=start, end_s=end, **limits) info = context_judge.view(result, decision, model) if decision.action == "adjust" and decision.window: # Trecho novo dentro dos limites: o juiz confere UMA vez de novo (sem novo ajuste). ns, ne = decision.window result2, model2 = ask(ns, ne) second = context_judge.decide(result2, start_s=ns, end_s=ne, allow_fix=False, **limits) first = info info = context_judge.view(result2, second, model2) info["first"] = {k: first[k] for k in ("viewerSummary", "checks", "failedCritical", "reasonPt", "pt")} info["window"] = [round(ns, 2), round(ne, 2)] if second.action == "approve": info["decision"] = "adjust" info["contextLine"] = second.context_line or decision.context_line info["reasonPt"] = f"{decision.reason_pt} Conferido de novo: aprovado." update["start_s"], update["end_s"] = round(ns, 2), round(ne, 2) else: info["decision"] = "discard" info["contextLine"] = "" info["reasonPt"] = (f"Descartado pelo juiz depois do ajuste para {ns:.0f}–{ne:.0f}s: " f"{second.reason_pt.removeprefix('Descartado pelo juiz: ')}") if info["decision"] == "discard": update["status"] = "discarded" judge_info["discardedBy"] = "context" judge_info["context"] = info log.info("juiz de contexto no corte %s: %s (%s)", clip["id"], info["decision"], info["reasonPt"][:160]) except (JudgeError, json.JSONDecodeError, KeyError, ValueError, TypeError) as exc: judge_info["context"] = {"error": str(exc)[:300]} log.warning("juiz de contexto falhou no corte %s: %s (fica a decisão do editor)", clip["id"], exc) def translate_clip(self, clip_id: int, lo: float | None = None, hi: float | None = None, force: bool = False) -> dict | None: """Fonte em inglês (doc/clipador/IDIOMAS.md): a fala de [lo, hi] (padrão: o trecho do corte) em frases com tempo da sessão + tradução em português, em `clips.translation_json`. Serve ao painel ("o que ele disse") e à legenda de desenvolvimento (`caption.translation`). Reaproveita a tradução que já cobre o trecho. Sessão em português, IA desligada ou falha da IA → None (o corte segue sem tradução).""" clip = self.db.get("SELECT * FROM clips WHERE id = ?", clip_id) session = self.db.get("SELECT * FROM sessions WHERE id = ?", clip["session_id"]) if clip else None if not clip or not session or self.intel.lang(session) != "en" or not self.judge.enabled: return None lo = clip["start_s"] if lo is None else lo hi = clip["end_s"] if hi is None else hi current = loads(clip.get("translation_json"), None) if (isinstance(current, dict) and not force and current.get("startS", 1e12) <= lo + 0.5 and current.get("endS", -1) >= hi - 0.5 and all("speaker" in line for line in current.get("lines") or [])): # antiga, sem falante: refaz return current tl = self.load_timeline(session["id"], max(0.0, lo - 30)) # Frases que nunca misturam falantes (doc/clipador/FALANTES.md); cada linha diz quem fala (`speaker`: # "streamer" ou "otherN") — a legenda de desenvolvimento e a dublagem escolhem posição e voz por ela. items = phrases([w for w in tl["words"] if lo - 0.3 <= w.start <= hi], with_speaker=True) if not items: return None try: pt = self.judge.translate_lines([text for _, _, text, _ in items]) except (JudgeError, json.JSONDecodeError, KeyError, ValueError) as exc: log.warning("tradução da fala do corte %s falhou: %s", clip_id, exc) return None data = {"language": "pt-BR", "startS": round(lo, 2), "endS": round(hi, 2), "model": self.judge.responder(), "lines": [{"s": round(s, 3), "e": round(e, 3), "text": text, "pt": tr, "speaker": speaker} for (s, e, text, speaker), tr in zip(items, pt)]} self.db.run("UPDATE clips SET translation_json = ? WHERE id = ?", json.dumps(data, ensure_ascii=False), clip_id) return data def render_pending(self) -> None: self.recover_orphan_renders() self.discard_pending_duplicates() # Vídeos finais primeiro: o corte já foi aprovado e a publicação está esperando por ele (REVISAO.md). for clip in self.db.all("SELECT * FROM clips WHERE final_status = 'pending' AND status IN ('approved', 'published')" " ORDER BY updated_at, id LIMIT 3"): if self.stop_event.is_set(): return self.render_final(clip) for clip in self.db.all("SELECT * FROM clips WHERE status = 'pending' ORDER BY score DESC, id LIMIT 3"): if self.stop_event.is_set(): return self.render_clip(clip) def discard_pending_duplicates(self) -> list[tuple[int, int]]: """Pendentes/renderizando que são o mesmo momento de um corte pronto, aprovado, publicado, REJEITADO, de um corte apagado que estava num desses estados (`clip_delete.marks`) ou de um pendente mais antigo saem da fila como descartados, dizendo de qual — o mesmo conjunto do veto depois do juiz (`VETO_STATUSES`). Descartado pela IA não veta. Não mexe em corte manual nem em corte que você exportou do editor. Devolve [(descartado, original)].""" rows = self.db.all(f"SELECT c.*, e.origin AS edit_origin, e.exported_at AS edit_exported_at FROM clips c " f"LEFT JOIN edits e ON e.clip_id = c.id WHERE c.status IN {VETO_STATUSES} ORDER BY c.id") kept = [r for r in rows if r["status"] in ("ready", "approved", "published", "rejected")] for session_id in {r["session_id"] for r in rows if r["status"] in ("pending", "rendering")}: kept += [m for m in clip_delete.marks(self.db, session_id) if m["status"] in VETO_STATUSES] out = [] for clip in (r for r in rows if r["status"] in ("pending", "rendering")): mine = clip["source"] == "manual" or clip["edit_origin"] == "user" or clip["edit_exported_at"] dup = None if mine or clip["id"] in self._rendering else duplicate_of(clip, kept) if not dup: kept.append(clip) continue judge_info = loads(clip["judge_json"], None) or {} judge_info = judge_info if isinstance(judge_info, dict) else {} judge_info["duplicateOf"] = dup["id"] why = ("que você apagou" if dup.get("deleted") else "que você rejeitou" if dup["status"] == "rejected" else "mesmo momento") judge_info["reason"] = (f"Duplicado do corte {dup['id']} ({why}). " + str(judge_info.get("reason") or "")).strip() self.db.run("UPDATE clips SET status = 'discarded', judge_json = ?, updated_at = ? WHERE id = ? AND status IN ('pending', 'rendering')", json.dumps(judge_info, ensure_ascii=False), now(), clip["id"]) log.info("corte %s saiu da fila: mesmo momento do corte %s", clip["id"], dup["id"]) out.append((clip["id"], dup["id"])) return out def recover_orphan_renders(self) -> None: """Corte em 'rendering' que este processo não está renderizando há mais de `ORPHAN_RENDER_S` (uma falha deixou para trás) volta para a fila; depois de `MAX_RENDER_ATTEMPTS` vezes, vira 'error'.""" limit = time.time() - ORPHAN_RENDER_S for clip in self.db.all("SELECT id, updated_at FROM clips WHERE status = 'rendering'"): if clip["id"] in self._rendering: continue try: updated = datetime.fromisoformat(clip["updated_at"]).timestamp() except (TypeError, ValueError): updated = 0.0 if updated > limit: continue attempts = self._render_attempts.get(clip["id"], 0) + 1 self._render_attempts[clip["id"]] = attempts if attempts >= MAX_RENDER_ATTEMPTS: self._clip_error(clip["id"], f"render interrompido {attempts} vezes sem terminar") else: log.warning("corte %s estava preso em 'rendering': volta para a fila (vez %d)", clip["id"], attempts) self.db.run("UPDATE clips SET status = 'pending', updated_at = ? WHERE id = ? AND status = 'rendering'", now(), clip["id"]) def render_clip(self, clip: dict) -> None: """Renderiza um corte. QUALQUER falha vira 'error' com a mensagem (antes, uma exceção não prevista — medido 16/11/2026: KeyError da legenda — deixava o corte preso em 'rendering' e reiniciava o laço).""" with self.lock: # Apagado depois de a fila ler a lista (clip_delete apaga sob este mesmo trinco): não renderiza. if not self.db.get("SELECT 1 FROM clips WHERE id = ?", clip["id"]): return self._rendering.add(clip["id"]) try: self._render_clip(clip) except Exception as exc: # noqa: BLE001 - o corte nunca fica preso: registra e segue para o próximo log.exception("render do corte %s falhou", clip["id"]) self._clip_error(clip["id"], f"falha inesperada no render: {type(exc).__name__}: {exc}") finally: with self.lock: self._rendering.discard(clip["id"]) def _render_clip(self, clip: dict) -> None: session = self.db.get("SELECT * FROM sessions WHERE id = ?", clip["session_id"]) segments = self.db.all( "SELECT * FROM segments WHERE session_id = ? AND end_s > ? AND start_s < ? ORDER BY idx", clip["session_id"], clip["start_s"], clip["end_s"]) if not segments or segments[-1]["end_s"] < clip["end_s"] - 0.5: if session and session["status"] == "recording": return # o fim do trecho ainda não foi gravado if any(s["deleted"] for s in segments) or not segments: self._clip_error(clip["id"], "os blocos gravados deste trecho já foram apagados") return self.db.run("UPDATE clips SET status = 'rendering', updated_at = ? WHERE id = ?", now(), clip["id"]) out_dir = self.settings.clips_dir / str(clip["session_id"]) out = out_dir / f"clip-{clip['id']}.mp4" thumb = out_dir / f"clip-{clip['id']}.jpg" if not session: self._clip_error(clip["id"], "sessão do corte não existe mais") return # Um caminho só: projeto de edição → FFmpeg. Sem projeto, a IA gera um agora (trecho pela análise, silêncios, # legenda, gancho, zoom no pico) e ele fica salvo; o editor abre esse mesmo projeto. from . import editor, editor_api # import tardio: editor_api importa o worker indiretamente pelo main try: edit = editor_api.ensure_edit(self, clip, session) clip = self.db.get("SELECT * FROM clips WHERE id = ?", clip["id"]) or clip cover = editor_api.render_clip_edit(self, clip, session, edit, out, thumb) except (media.MediaError, editor.EditError) as exc: self._clip_error(clip["id"], str(exc)) return self.db.run("UPDATE edits SET cover = ? WHERE clip_id = ?", cover, clip["id"]) self.db.run("UPDATE clips SET status = 'ready', file = ?, thumb = ?, error = NULL, updated_at = ? WHERE id = ?", rel(out), rel(thumb), now(), clip["id"]) self.drop_final(clip["id"]) # vídeo de revisão novo = conteúdo novo: o final antigo deixa de valer self._render_attempts.pop(clip["id"], None) # ---------- vídeo final (doc/clipador/REVISAO.md) def queue_final(self, clip_id: int) -> str | None: """Corte aprovado: pede o vídeo FINAL (sem camadas de desenvolvimento). Se o vídeo de revisão não teve nenhuma camada `dev` (`review_dev_json` = []), ele já é o final: reaproveita sem renderizar. Devolve o `final_status`.""" with self.db.lock: clip = self.db.get("SELECT c.*, e.cover AS edit_cover FROM clips c LEFT JOIN edits e ON e.clip_id = c.id" " WHERE c.id = ?", clip_id) if not clip or clip["status"] not in ("approved", "published"): return None if loads(clip["review_dev_json"], None) == [] and clip["file"]: self.db.run("UPDATE clips SET final_status = 'ready', final_file = ?, final_thumb = ?, final_cover = ?," " final_error = NULL, final_at = ? WHERE id = ?", clip["file"], clip["thumb"], clip["edit_cover"], now(), clip_id) return "ready" self.db.run("UPDATE clips SET final_status = 'pending', final_file = NULL, final_thumb = NULL, final_cover = NULL," " final_error = NULL, final_at = NULL WHERE id = ?", clip_id) self.wake_clips.set() return "pending" def drop_final(self, clip_id: int) -> None: """O final deixa de valer (aprovação desfeita, corte editado ou renderizado de novo). O arquivo fica no disco até o próximo final (mesmo nome) ou até apagar o corte; nada mais aponta para ele.""" self.db.run("UPDATE clips SET final_status = NULL, final_file = NULL, final_thumb = NULL, final_cover = NULL," " final_error = NULL, final_at = NULL WHERE id = ?", clip_id) def render_final(self, clip: dict) -> None: """Renderiza o vídeo final de um corte aprovado. Falha vira `final_status = 'error'` (o corte continua aprovado; "tentar de novo" no painel = POST /v1/clips/{id}/final).""" with self.lock: # Apagado depois de a fila ler a lista, ou já em render: não começa (clip_delete recusa enquanto estiver aqui). if clip["id"] in self._rendering or not self.db.get("SELECT 1 FROM clips WHERE id = ?", clip["id"]): return self._rendering.add(clip["id"]) try: self._render_final(clip) except Exception as exc: # noqa: BLE001 - nunca fica preso em 'rendering' log.exception("vídeo final do corte %s falhou", clip["id"]) self._final_error(clip["id"], f"falha inesperada no render final: {type(exc).__name__}: {exc}") finally: with self.lock: self._rendering.discard(clip["id"]) def _render_final(self, clip: dict) -> None: taken = self.db.run("UPDATE clips SET final_status = 'rendering', final_error = NULL WHERE id = ? AND final_status = 'pending'" " AND status IN ('approved', 'published')", clip["id"]).rowcount if not taken: return session = self.db.get("SELECT * FROM sessions WHERE id = ?", clip["session_id"]) if not session: self._final_error(clip["id"], "sessão do corte não existe mais") return segments = self.db.all("SELECT deleted FROM segments WHERE session_id = ? AND end_s > ? AND start_s < ?", clip["session_id"], clip["start_s"], clip["end_s"]) if not segments or any(s["deleted"] for s in segments): self._final_error(clip["id"], "os blocos gravados deste trecho já foram apagados") return out_dir = self.settings.clips_dir / str(clip["session_id"]) out = out_dir / f"clip-{clip['id']}-final.mp4" thumb = out_dir / f"clip-{clip['id']}-final.jpg" from . import editor, editor_api # import tardio (ver _render_clip) t = time.monotonic() try: edit = editor_api.ensure_edit(self, clip, session) cover = editor_api.render_clip_edit(self, clip, session, edit, out, thumb, dev=False) except (media.MediaError, editor.EditError) as exc: self._final_error(clip["id"], str(exc)) return # Só grava se ninguém desfez a aprovação (ou editou) durante o render: aí `final_status` já não é 'rendering'. done = self.db.run("UPDATE clips SET final_status = 'ready', final_file = ?, final_thumb = ?, final_cover = ?, final_error = NULL," " final_at = ? WHERE id = ? AND final_status = 'rendering'", rel(out), rel(thumb), cover, now(), clip["id"]).rowcount log.info("vídeo final do corte %s em %.1f s%s", clip["id"], time.monotonic() - t, "" if done else " (descartado: o corte mudou durante o render)") def _final_error(self, clip_id: int, message: str) -> None: self.db.run("UPDATE clips SET final_status = 'error', final_error = ? WHERE id = ? AND final_status IN ('pending', 'rendering')", message[:500], clip_id) def _clip_error(self, clip_id: int, message: str) -> None: self.db.run("UPDATE clips SET status = 'error', error = ?, updated_at = ? WHERE id = ?", message[:500], now(), clip_id) def finish_if_done(self, session: dict) -> None: if session["status"] not in ("processing", "stopped"): return with self.lock: if session["id"] in self.captures: return left = self.db.get("SELECT COUNT(*) AS n FROM segments WHERE session_id = ? AND analyzed = 0 AND deleted = 0", session["id"])["n"] busy = self.db.get("SELECT COUNT(*) AS n FROM clips WHERE session_id = ? AND status IN ('candidate', 'pending', 'rendering')", session["id"])["n"] if left == 0 and busy == 0: # A passada final (live=False, sessão inteira) já rodou em find_new_clips neste mesmo ciclo. self.db.run("UPDATE sessions SET status = 'done' WHERE id = ?", session["id"]) def prune(self) -> None: if self.settings.keep_hours <= 0: return limit = time.time() - self.settings.keep_hours * 3600 for seg in self.db.all("SELECT * FROM segments WHERE deleted = 0 AND analyzed = 1 AND wall_end < ? LIMIT 200", limit): # Também guarda o trecho de quem ainda vai precisar do vídeo final: aprovado com final por fazer ou com erro, e # pronto para aprovar cujo vídeo de revisão tem camadas de desenvolvimento (ou não se sabe) — REVISAO.md. needed = self.db.get( "SELECT 1 FROM clips WHERE session_id = ? AND start_s < ? AND end_s > ? AND (" "status IN ('candidate', 'pending', 'rendering')" " OR (status IN ('approved', 'published') AND final_status IN ('pending', 'rendering', 'error'))" " OR (status = 'ready' AND COALESCE(review_dev_json, '') != '[]'))", seg["session_id"], seg["end_s"], seg["start_s"]) if needed: continue (REPO_ROOT / seg["file"]).unlink(missing_ok=True) self.db.run("UPDATE segments SET deleted = 1 WHERE session_id = ? AND idx = ?", seg["session_id"], seg["idx"]) def delete_session(self, session_id: int) -> None: self.stop_session(session_id, pause_monitor=False) session = self.db.get("SELECT * FROM sessions WHERE id = ?", session_id) if not session: return self.db.run("DELETE FROM sessions WHERE id = ?", session_id) for folder in (REPO_ROOT / session["dir"] if session["dir"] else None, self.settings.clips_dir / str(session_id)): if folder and folder.is_dir(): shutil.rmtree(folder, ignore_errors=True) # ---------- nomes def streamer_name(self, session: dict) -> str: if session.get("channel_id"): channel = self.db.get("SELECT display_name FROM channels WHERE id = ?", session["channel_id"]) if channel: return channel["display_name"] source = parse_source(session["url"]) return source.channel.lstrip("@") or source.platform def channel_label(self, session: dict) -> str: source = parse_source(session["url"]) host = {"twitch": "twitch.tv", "kick": "kick.com", "youtube": "youtube.com"}[source.platform] name = source.channel or self.streamer_name(session) return f"{host}/{name.lstrip('@') if source.platform != 'youtube' else name}" def channel_link(self, session: dict) -> str: return "https://" + self.channel_label(session) if parse_source(session["url"]).channel else session["url"] def wall_to_t(wall: float, segments: list[dict]) -> float | None: """Relógio de parede → segundos da gravação, pelo bloco em que aquela hora caiu.""" if not segments: return None for seg in segments: if wall <= seg["wall_end"]: t = seg["end_s"] - (seg["wall_end"] - wall) if t < 0: return None # mensagem de antes do início da gravação # Dentro de uma pausa do Streamlink (anúncio filtrado) a mensagem cai no começo do bloco seguinte. return max(seg["start_s"], t) last = segments[-1] return last["end_s"] + (wall - last["wall_end"])