370 lines
16 KiB
Python
370 lines
16 KiB
Python
"""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)
|
||
);
|
||
""",
|
||
# v16: sem efeito. Estava reservada às expressões do rosto, que acabaram não precisando de migração (os campos novos
|
||
# ficam no JSON de `face_track`, doc/clipador/EXPRESSOES.md). Fica para a numeração não mudar.
|
||
"""
|
||
SELECT 1;
|
||
""",
|
||
# v17: Equipe de IA (doc/clipador/EQUIPE-IA.md).
|
||
# - `ai_calls`: cada chamada de IA (papel, IA, tamanho do prompt e das imagens, tokens quando a CLI informa, tempo)
|
||
# para comparar custo por hora (F0). Sem FK para a sessão: a medição fica depois de apagar a sessão.
|
||
# - `scene_notes`: frase curta do que está na tela num instante (escrita pela varredura/analista ao ver os quadros);
|
||
# vira o campo `v` da linha do tempo JSON.
|
||
# - `clips.owner_label`/`owner_note`: avaliação do dono (bom / ruim / sem contexto) para o conjunto de avaliação.
|
||
"""
|
||
CREATE TABLE IF NOT EXISTS ai_calls (
|
||
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
||
at TEXT NOT NULL,
|
||
role TEXT NOT NULL,
|
||
purpose TEXT NOT NULL,
|
||
provider TEXT NOT NULL,
|
||
model TEXT NOT NULL,
|
||
ok INTEGER NOT NULL,
|
||
error TEXT,
|
||
ms INTEGER,
|
||
system_chars INTEGER,
|
||
prompt_chars INTEGER,
|
||
images INTEGER,
|
||
image_bytes INTEGER,
|
||
tokens_in INTEGER,
|
||
tokens_out INTEGER,
|
||
tokens_cached INTEGER,
|
||
session_id INTEGER,
|
||
clip_id INTEGER,
|
||
mode TEXT
|
||
);
|
||
CREATE INDEX IF NOT EXISTS ai_calls_at ON ai_calls (at);
|
||
CREATE TABLE IF NOT EXISTS scene_notes (
|
||
session_id INTEGER NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
|
||
t REAL NOT NULL,
|
||
source TEXT NOT NULL,
|
||
text TEXT NOT NULL,
|
||
created_at TEXT NOT NULL,
|
||
PRIMARY KEY (session_id, t, source)
|
||
);
|
||
ALTER TABLE clips ADD COLUMN owner_label TEXT CHECK (owner_label IN ('good', 'bad', 'no_context'));
|
||
ALTER TABLE clips ADD COLUMN owner_note TEXT;
|
||
""",
|
||
]
|
||
|
||
|
||
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
|