CenaForge: primeira versão pública

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>
This commit is contained in:
2026-11-17 16:35:09 -03:00
co-authored by Claude Opus 5.5
commit 84f30bbc2d
484 changed files with 74826 additions and 0 deletions
+113
View File
@@ -0,0 +1,113 @@
"""Worker do Publicador: UMA thread, UM job por vez, na ordem de chegada.
Máquina de estados do job: queued → running → done | failed | needs_login
queued → canceled (só pelo /cancel, antes de começar)
Persistente: os jobs ficam no SQLite. Se o serviço cair com um job em `running`, na subida ele vira `failed`
com "interrompido — tente de novo" (db.py) — não dá para saber se o vídeo chegou à rede.
"""
from __future__ import annotations
import logging
import threading
import time
from typing import Callable
from .db import Database, now
from .platforms.base import Progress, PublishError, PublishResult
log = logging.getLogger("publisher.worker")
Execute = Callable[[dict, Progress], PublishResult]
class Worker:
def __init__(self, db: Database, execute: Execute, maintenance: Callable[[], None] | None = None,
idle_wait_s: float = 2.0, maintenance_every_s: float = 3600.0):
self.db = db
self.execute = execute
self.maintenance = maintenance
self.idle_wait_s = idle_wait_s
self.maintenance_every_s = maintenance_every_s
self._wake = threading.Event()
self._stop = threading.Event()
self._thread: threading.Thread | None = None
self._current: str | None = None
self._last_maintenance = 0.0
@property
def busy(self) -> bool:
return self._current is not None
def start(self) -> None:
if self._thread and self._thread.is_alive():
return
self._stop.clear()
self._thread = threading.Thread(target=self._loop, name="publisher-worker", daemon=True)
self._thread.start()
def stop(self, timeout: float = 5) -> None:
self._stop.set()
self._wake.set()
if self._thread:
self._thread.join(timeout)
def wake(self) -> None:
self._wake.set()
def _loop(self) -> None:
while not self._stop.is_set():
try:
if not self.run_once():
if self.maintenance and time.time() - self._last_maintenance > self.maintenance_every_s:
self._last_maintenance = time.time()
self.maintenance()
self._wake.wait(self.idle_wait_s)
self._wake.clear()
except Exception: # noqa: BLE001 - o laço não pode morrer
log.exception("erro no laço do worker")
time.sleep(self.idle_wait_s)
def _set(self, job_id: str, **fields) -> None:
columns = ", ".join(f"{name} = ?" for name in fields)
self.db.run(f"UPDATE jobs SET {columns}, updated_at = ? WHERE job_id = ?", *fields.values(), now(), job_id)
def run_once(self) -> bool:
"""Pega o job mais antigo da fila e roda até o fim. False = fila vazia."""
row = self.db.get("SELECT * FROM jobs WHERE status = 'queued' ORDER BY created_at, rowid LIMIT 1")
if not row:
return False
job_id = row["job_id"]
# Reserva atômica: se alguém cancelou entre o SELECT e aqui, não roda.
claimed = self.db.run("UPDATE jobs SET status = 'running', step = 'Começando…', progress = 0, error = NULL, "
"updated_at = ? WHERE job_id = ? AND status = 'queued'", now(), job_id)
if claimed.rowcount != 1:
return True
self._current = job_id
last = [0.0]
def progress(step: str, fraction: float) -> None:
# Grava no máximo ~2x por segundo (o upload chama muito).
if time.time() - last[0] < 0.5 and fraction < 1:
return
last[0] = time.time()
self._set(job_id, step=step[:200], progress=max(0.0, min(1.0, float(fraction))))
try:
result = self.execute(row, progress)
except PublishError as exc:
status = "needs_login" if exc.kind in ("needs_login", "expired") else "failed"
self._set(job_id, status=status, error=exc.message,
step="Precisa entrar de novo" if status == "needs_login" else "Falhou")
log.info("job %s: %s (%s)", job_id, status, exc.message)
except Exception as exc: # noqa: BLE001
log.exception("job %s falhou com erro inesperado", job_id)
self._set(job_id, status="failed", step="Falhou",
error=f"Erro inesperado no Publicador ({type(exc).__name__}: {str(exc)[:200]}). Tente de novo.")
else:
self._set(job_id, status="done", step=result.step[:200], progress=1.0, remote_id=result.remote_id,
url=result.url, draft=1 if result.draft else 0, error=None)
log.info("job %s: concluído (%s)", job_id, result.url or result.remote_id or "sem link")
finally:
self._current = None
return True