Gerador de vídeos narrativos (Godot + FFmpeg), painel Next.js, serviço de voz, Clipador de lives e Publicador para YouTube, TikTok e Instagram. Inclui a leitura das visualizações dos posts para o Dashboard e o botão "Publicar no <rede>" nos cartões das publicações. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
271 lines
11 KiB
Python
271 lines
11 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);
|
||
""",
|
||
]
|
||
|
||
|
||
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'")
|
||
|
||
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
|