Pedido do dono: o vídeo da fila é de revisão (com as camadas `dev`, ex.: tradução);
ao aprovar, o serviço renderiza de novo sem elas, e só esse vai para as redes.
- db v14: clips.review_dev_json (camadas que entraram na revisão) e final_status/
final_file/final_thumb/final_cover/final_error/final_at; backfill dos cortes antigos.
- Motor: queue_final/drop_final/render_final; fila renderiza finais primeiro com
render_clip_edit(dev=False) em clip-<id>-final.mp4; revisão sem camada de teste
vira o final sem render novo; prune guarda os blocos de quem ainda precisa do final.
- API: clip traz review.devLayers, final e publishFile; aprovar enfileira o final;
desaprovar, mudar trecho, exportar, re-render e rejudge derrubam o final;
POST /v1/clips/{id}/final (tentar de novo).
- Painel: etiqueta na lista, player Final/Revisão e estado do final no modal
(gerando/pronto/erro com "Tentar de novo"), aviso no "Publicar"; o despachante
relê o corte antes de enviar e espera o final (clipPublishFile), nunca a revisão.
- Testes: clipper/tests/test_final_render.py e testes do despachante no painel.
- Doc: doc/clipador/REVISAO.md.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
1271 lines
74 KiB
Python
1271 lines
74 KiB
Python
"""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, layout, media
|
||
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_prompt
|
||
from .scoring import ChatMessage, Params, Word, find_moments, overlaps
|
||
from .sources import Source, parse_source
|
||
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)
|
||
|
||
|
||
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")}
|
||
self.judge = judge or Judge(saved.get("judge_provider", settings.judge_provider),
|
||
saved.get("judge_model", settings.judge_model), settings.data_dir / "judge",
|
||
saved.get("judge_analyst_model", ""))
|
||
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.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) -> dict:
|
||
return self.judge.describe() | {"minScore": self.min_score, "options": dict(self.intel.opts),
|
||
"lastScanError": self.intel.last_scan_error}
|
||
|
||
def set_judge_config(self, provider: str, model: str, min_score: float, analyst_model: str | 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)
|
||
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)]
|
||
self.db.many("INSERT INTO settings (key, value) VALUES (?, ?) ON CONFLICT (key) DO UPDATE SET value = excluded.value", rows)
|
||
return self.judge_config()
|
||
|
||
# ---------- 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) -> Path:
|
||
return media.grab_frame(self.settings.ffmpeg or "ffmpeg", segments, t, out_file)
|
||
|
||
# ---------- 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]
|
||
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), json.dumps([[w.start, w.end, w.word] for w in words], ensure_ascii=False), 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(Word(a, b, c) for a, b, c in loads(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)))
|
||
return {"segments": segments, "duration": duration, "loudness": loudness, "words": words, "chat": chat,
|
||
"analyzedUntil": analyzed_until}
|
||
|
||
# ---------- 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 = [Word(w.start - offset, w.end - offset, w.word) 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)
|
||
# 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 else 6
|
||
times = [f_lo + (hi - f_lo) * k / (n_frames - 1) for k in range(n_frames)]
|
||
frames = self.intel.frames(session, times, f"clip{clip['id']}")
|
||
# 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)
|
||
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=frames, backtrack_s=dur["backtrackS"], min_s=dur["minS"], max_s=dur["maxS"],
|
||
face=self.face.summary(session, lo, hi), lang=lang)
|
||
analysis = None
|
||
try:
|
||
# Dois juízes: o ANALISTA (vê os frames) diz o que aconteceu; o EDITOR decide e escreve a partir disso.
|
||
try:
|
||
analysis = self.judge.analyze(prompt, [p for _, p in frames], lang=lang)
|
||
except (JudgeError, json.JSONDecodeError, KeyError, ValueError) as exc:
|
||
log.warning("analista falhou no corte %s: %s (editor segue sozinho)", clip["id"], exc)
|
||
editor_prompt = prompt + ("\n\n" + analysis_block(analysis, lang) if analysis else "")
|
||
# Sem análise, o editor recebe os frames; 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 [p for _, p in frames],
|
||
lo=lo, hi=hi, min_s=layout.min_target({"duration": dur}), 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.analyst_model or self.judge.model) if analysis else None}}
|
||
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).
|
||
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 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):
|
||
return current
|
||
tl = self.load_timeline(session["id"], max(0.0, lo - 30))
|
||
items = phrases([w for w in tl["words"] if lo - 0.3 <= w.start <= hi])
|
||
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}
|
||
for (s, e, text), 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"])
|