Files
CenaForge/clipper/app/db.py
T
MateuusandClaude Opus 5.5 439e111052 Integração: falantes + dublagem + vídeo final
- editor_api: importa dub e speakers juntos.
- voice_chunks (falantes) vira a migração v15, depois da v14 do vídeo final (antes era criada fora das migrações).
- dub.voice_for: qualquer voz que não é o streamer (other1, other2…) usa a segunda voz da dublagem.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 03:59:44 -03:00

325 lines
15 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""Estado do Clipador em data/clipper/clipper.db (SQLite). Canais monitorados, sessões de gravação, blocos
gravados, chat e cortes. As contas (e o vínculo conta ↔ canal) ficam no banco do painel."""
from __future__ import annotations
import json
import sqlite3
import threading
from datetime import datetime, timezone
from pathlib import Path
from typing import Any
SCHEMA = [
"""
CREATE TABLE channels (
id TEXT PRIMARY KEY,
platform TEXT NOT NULL CHECK (platform IN ('twitch', 'youtube', 'kick')),
channel TEXT NOT NULL,
url TEXT NOT NULL,
display_name TEXT NOT NULL,
monitor INTEGER NOT NULL DEFAULT 1,
authorized INTEGER NOT NULL DEFAULT 0,
threshold REAL,
created_at TEXT NOT NULL,
last_check_at TEXT,
last_status TEXT NOT NULL DEFAULT ''
);
CREATE TABLE sessions (
id INTEGER PRIMARY KEY AUTOINCREMENT,
channel_id TEXT REFERENCES channels(id) ON DELETE SET NULL,
platform TEXT NOT NULL,
kind TEXT NOT NULL CHECK (kind IN ('live', 'vod')),
url TEXT NOT NULL,
title TEXT NOT NULL DEFAULT '',
status TEXT NOT NULL CHECK (status IN ('starting', 'recording', 'processing', 'done', 'stopped', 'error', 'interrupted')),
chat_status TEXT NOT NULL DEFAULT 'off',
dir TEXT NOT NULL,
duration_s REAL NOT NULL DEFAULT 0,
started_at TEXT NOT NULL,
ended_at TEXT,
error TEXT
);
CREATE TABLE segments (
session_id INTEGER NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
idx INTEGER NOT NULL,
file TEXT NOT NULL,
start_s REAL NOT NULL,
end_s REAL NOT NULL,
wall_end REAL NOT NULL,
analyzed INTEGER NOT NULL DEFAULT 0,
loudness_json TEXT,
words_json TEXT,
transcript_error TEXT,
deleted INTEGER NOT NULL DEFAULT 0,
PRIMARY KEY (session_id, idx)
);
CREATE TABLE chat (
session_id INTEGER NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
wall REAL NOT NULL,
user TEXT NOT NULL,
text TEXT NOT NULL
);
CREATE INDEX chat_session_wall ON chat (session_id, wall);
CREATE TABLE clips (
id INTEGER PRIMARY KEY AUTOINCREMENT,
session_id INTEGER NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
peak_s REAL NOT NULL,
start_s REAL NOT NULL,
end_s REAL NOT NULL,
score REAL NOT NULL,
source TEXT NOT NULL,
reasons_json TEXT NOT NULL DEFAULT '{}',
title TEXT NOT NULL DEFAULT '',
caption TEXT NOT NULL DEFAULT '',
transcript TEXT NOT NULL DEFAULT '',
status TEXT NOT NULL CHECK (status IN ('candidate', 'discarded', 'pending', 'rendering', 'ready', 'approved', 'rejected', 'published', 'error')),
judge_json TEXT,
file TEXT,
thumb TEXT,
error TEXT,
created_at TEXT NOT NULL,
updated_at TEXT NOT NULL
);
""",
# v2: configurações trocadas pelo painel em tempo de execução (juiz: provedor, modelo, nota mínima).
"""
CREATE TABLE settings (
key TEXT PRIMARY KEY,
value TEXT NOT NULL
);
""",
# v3: contexto do jogo, varredura da IA, emotes que aprendem e configuração do corte (layout/legenda).
"""
ALTER TABLE sessions ADD COLUMN game TEXT NOT NULL DEFAULT '';
ALTER TABLE sessions ADD COLUMN game_source TEXT NOT NULL DEFAULT '';
ALTER TABLE sessions ADD COLUMN screen_game TEXT NOT NULL DEFAULT '';
ALTER TABLE sessions ADD COLUMN games_json TEXT NOT NULL DEFAULT '[]';
ALTER TABLE sessions ADD COLUMN room_id TEXT;
ALTER TABLE sessions ADD COLUMN settings_json TEXT;
ALTER TABLE sessions ADD COLUMN scanned_until REAL NOT NULL DEFAULT 0;
ALTER TABLE sessions ADD COLUMN memory_json TEXT NOT NULL DEFAULT '[]';
ALTER TABLE sessions ADD COLUMN cam_json TEXT;
ALTER TABLE clips ADD COLUMN learned INTEGER NOT NULL DEFAULT 0;
ALTER TABLE channels ADD COLUMN settings_json TEXT;
ALTER TABLE chat ADD COLUMN emotes TEXT;
CREATE TABLE games (
id TEXT PRIMARY KEY,
name TEXT NOT NULL,
status TEXT NOT NULL CHECK (status IN ('pending', 'ready', 'error')),
profile_json TEXT,
error TEXT,
model TEXT,
researched_at TEXT
);
CREATE TABLE emotes (
channel_key TEXT NOT NULL,
name TEXT NOT NULL,
source TEXT NOT NULL,
uses INTEGER NOT NULL DEFAULT 0,
weight REAL NOT NULL DEFAULT 0,
first_seen TEXT NOT NULL,
last_seen TEXT NOT NULL,
PRIMARY KEY (channel_key, name)
);
""",
# v4: projeto do editor de cortes (JSON versionado por corte; `rev` sobe a cada gravação — autosave sem atropelar).
"""
CREATE TABLE edits (
clip_id INTEGER PRIMARY KEY REFERENCES clips(id) ON DELETE CASCADE,
project_json TEXT NOT NULL,
rev INTEGER NOT NULL DEFAULT 1,
cover TEXT,
exported_at TEXT,
created_at TEXT NOT NULL,
updated_at TEXT NOT NULL
);
""",
# v5: rastreio de reação (face.py) — série por segundo do rosto do streamer, uma linha por bloco gravado.
# status: done | no_cam | error. `data_json` = {cam, crop, fps, backend, seconds: [FaceSecond…]} (quadro inteiro).
"""
CREATE TABLE face_track (
session_id INTEGER NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
idx INTEGER NOT NULL,
status TEXT NOT NULL CHECK (status IN ('done', 'no_cam', 'error')),
data_json TEXT,
error TEXT,
updated_at TEXT NOT NULL,
PRIMARY KEY (session_id, idx)
);
""",
# v6: perfil do jogo editável pelo painel. `notes_json` = pedidos que você fez à IA ([{text, at}]) — entram de
# novo em toda pesquisa, para "Pesquisar de novo" não apagar o que você acrescentou; `edited_at` = última edição
# à mão ou por pedido seu.
"""
ALTER TABLE games ADD COLUMN notes_json TEXT NOT NULL DEFAULT '[]';
ALTER TABLE games ADD COLUMN edited_at TEXT;
""",
# v7: a IA entrega o projeto de edição pronto. `origin` = quem fez a versão atual (ai = pipeline; user = você
# salvou no editor); `ai_project_json` guarda o que a IA gerou, para "voltar ao projeto da IA".
"""
ALTER TABLE edits ADD COLUMN origin TEXT NOT NULL DEFAULT 'ai' CHECK (origin IN ('ai', 'user'));
ALTER TABLE edits ADD COLUMN ai_project_json TEXT;
""",
# v8: formato em que o corte foi renderizado (`format.aspect` da configuração efetiva no render): o painel
# desenha o player na proporção certa. Cortes antigos foram todos verticais (1080×1920).
"""
ALTER TABLE clips ADD COLUMN aspect TEXT NOT NULL DEFAULT 'vertical' CHECK (aspect IN ('vertical', 'horizontal'));
""",
# v9: o que a captura gravou de fato (app/capture.py): qualidade pedida + resolução, qps, codec e taxa lidos do
# 1º bloco de cada execução (início ou retomada). Sessões antigas ficam NULL (gravadas com o teto antigo de 720p).
"""
ALTER TABLE sessions ADD COLUMN capture_json TEXT;
""",
# v10: marca mínima de cada corte apagado (app/clip_delete.py): pico, trecho final e janela original do
# candidato. A regra anti-duplicado conta com ela como se o corte ainda existisse, então apagar um descartado
# não faz a IA recriar o mesmo momento na passada seguinte da live (nem na passada final da sessão).
"""
CREATE TABLE deleted_clips (
clip_id INTEGER PRIMARY KEY,
session_id INTEGER NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
peak_s REAL NOT NULL,
start_s REAL NOT NULL,
end_s REAL NOT NULL,
candidate_start_s REAL,
candidate_end_s REAL,
status TEXT NOT NULL,
source TEXT NOT NULL,
title TEXT NOT NULL DEFAULT '',
deleted_at TEXT NOT NULL
);
CREATE INDEX deleted_clips_session ON deleted_clips (session_id);
""",
# v11: (a) parar uma sessão à mão pausa o monitor da fonte (`monitor_paused_at` + a sessão que motivou): o monitor
# não abre sessão nova enquanto a pausa existir; religar (PATCH monitor=true, gravar pelo link ou retomar) limpa.
# (b) idioma falado na live, por fonte e por sessão ('' = CLIPPER_LANGUAGE): transcrição e textos da IA.
"""
ALTER TABLE channels ADD COLUMN monitor_paused_at TEXT;
ALTER TABLE channels ADD COLUMN monitor_paused_session INTEGER;
ALTER TABLE channels ADD COLUMN language TEXT NOT NULL DEFAULT '';
ALTER TABLE sessions ADD COLUMN language TEXT NOT NULL DEFAULT '';
""",
# v12: perfil do jogo em dois idiomas (doc/clipador/JOGOS.md). `profile_json` continua sendo o português (o que o
# painel mostra); `profile_ai_json` é o inglês, que vai nos prompts; `translated_at` = quando uma versão foi gerada
# da outra; `aliases_json` = outros nomes do jogo (categoria "Grand Theft Auto VI" e tela "GTA 6" → mesmo perfil).
"""
ALTER TABLE games ADD COLUMN profile_ai_json TEXT;
ALTER TABLE games ADD COLUMN translated_at TEXT;
ALTER TABLE games ADD COLUMN aliases_json TEXT NOT NULL DEFAULT '[]';
""",
# v13: fonte em inglês (doc/clipador/IDIOMAS.md): a fala do corte em frases com tempo + tradução em português,
# para o painel e para a legenda de desenvolvimento (inglês em cima, português embaixo). NULL = não traduzido.
"""
ALTER TABLE clips ADD COLUMN translation_json TEXT;
""",
# v14: vídeo de revisão × vídeo final (doc/clipador/REVISAO.md). O render da fila é o de REVISÃO (com as camadas
# `dev` ligadas); ao aprovar, sai o FINAL (`dev=False`) em `clip-<id>-final.mp4`, que é o único que se publica.
# `review_dev_json` = camadas de desenvolvimento que entraram no arquivo de revisão (["translation", ...]; [] =
# nenhuma → o de revisão já é o final; NULL = desconhecido → renderiza o final). `final_status`: pending |
# rendering | ready | error (NULL = sem final: não aprovado, ou a aprovação foi desfeita/editada).
# Cortes de antes da v14: a única camada de desenvolvimento era a tradução, que só entra com `translation_json`;
# sem ela o arquivo já é limpo ([]).
"""
ALTER TABLE clips ADD COLUMN review_dev_json TEXT;
ALTER TABLE clips ADD COLUMN final_status TEXT CHECK (final_status IN ('pending', 'rendering', 'ready', 'error'));
ALTER TABLE clips ADD COLUMN final_file TEXT;
ALTER TABLE clips ADD COLUMN final_thumb TEXT;
ALTER TABLE clips ADD COLUMN final_cover TEXT;
ALTER TABLE clips ADD COLUMN final_error TEXT;
ALTER TABLE clips ADD COLUMN final_at TEXT;
UPDATE clips SET review_dev_json = '[]' WHERE file IS NOT NULL AND translation_json IS NULL;
UPDATE clips SET final_status = 'pending' WHERE status = 'approved' AND review_dev_json IS NULL AND file IS NOT NULL;
UPDATE clips SET final_status = 'ready', final_file = file, final_thumb = thumb, final_at = updated_at
WHERE status IN ('approved', 'published') AND review_dev_json = '[]';
""",
# v15: falantes (doc/clipador/FALANTES.md). Impressões de voz dos trechos de fala de cada bloco (WeSpeaker), com o
# volume; as vozes da sessão são agrupadas sob demanda a partir daqui (speakers.SpeakerService).
"""
CREATE TABLE IF NOT EXISTS voice_chunks (
session_id INTEGER NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
idx INTEGER NOT NULL,
data_json TEXT NOT NULL,
updated_at TEXT NOT NULL,
PRIMARY KEY (session_id, idx)
);
""",
]
def now() -> str:
return datetime.now(timezone.utc).isoformat(timespec="seconds")
class Database:
def __init__(self, path: Path):
path.parent.mkdir(parents=True, exist_ok=True)
self.lock = threading.RLock()
self.conn = sqlite3.connect(path, check_same_thread=False, isolation_level=None)
self.conn.row_factory = sqlite3.Row
self.conn.executescript("PRAGMA journal_mode = WAL; PRAGMA foreign_keys = ON; PRAGMA busy_timeout = 3000;")
self._migrate()
# Sessões que estavam gravando quando o serviço caiu: a captura morreu junto. Ficam 'interrupted' e o motor
# tenta retomar as lives sozinho na subida (Engine.start → resume_interrupted); quem estava só processando
# volta a processar.
self.interrupted_on_start = [r["id"] for r in self.all(
"SELECT id FROM sessions WHERE status IN ('starting', 'recording') AND kind = 'live'")]
self.run("UPDATE sessions SET status = 'interrupted', ended_at = ?, chat_status = 'off' WHERE status IN ('starting', 'recording')", now())
# Antes as que estavam 'processing' também viravam 'interrupted' e paravam; processar não depende da captura.
# Chat só fica "conectado" enquanto grava (sessões antigas ficaram com o estado velho gravado).
self.run("UPDATE sessions SET chat_status = 'off' WHERE status NOT IN ('starting', 'recording') AND chat_status != 'off'")
self.run("UPDATE clips SET status = 'pending' WHERE status = 'rendering'")
self.run("UPDATE clips SET final_status = 'pending' WHERE final_status = 'rendering'") # vídeo final idem
def _migrate(self) -> None:
version = self.conn.execute("PRAGMA user_version").fetchone()[0]
for v in range(version, len(SCHEMA)):
with self.lock:
self.conn.execute("BEGIN")
try:
for statement in _split(SCHEMA[v]):
self.conn.execute(statement)
self.conn.execute(f"PRAGMA user_version = {v + 1}")
self.conn.execute("COMMIT")
except Exception:
self.conn.execute("ROLLBACK")
raise
def run(self, sql: str, *params: Any) -> sqlite3.Cursor:
with self.lock:
return self.conn.execute(sql, params)
def many(self, sql: str, rows: list[tuple]) -> None:
with self.lock:
self.conn.execute("BEGIN")
try:
self.conn.executemany(sql, rows)
self.conn.execute("COMMIT")
except Exception:
self.conn.execute("ROLLBACK")
raise
def all(self, sql: str, *params: Any) -> list[dict]:
with self.lock:
return [dict(r) for r in self.conn.execute(sql, params).fetchall()]
def get(self, sql: str, *params: Any) -> dict | None:
with self.lock:
row = self.conn.execute(sql, params).fetchone()
return dict(row) if row else None
def close(self) -> None:
with self.lock:
self.conn.close()
def _split(script: str) -> list[str]:
# executescript faria COMMIT implícito no meio da transação; executamos comando por comando.
return [s.strip() for s in script.split(";") if s.strip()]
def loads(raw: str | None, default: Any) -> Any:
try:
return json.loads(raw) if raw else default
except json.JSONDecodeError:
return default