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
+125
View File
@@ -0,0 +1,125 @@
"""Fila de trabalho: concorrência limitada, fila limitada POR CHAVE, timeout de espera e de execução.
- A cota de espera é por `owner` (o `keyId` de quem chamou): uma chave cheia recebe `QueueFull`, as outras
continuam entrando. Homologação e produção usam o mesmo serviço com chaves diferentes; o teste de uma não
pode recusar a doação paga da outra.
- A vaga de execução (CPU) é global, mas é entregue em rodízio entre as chaves que estão esperando, e a chave
que acabou de rodar vai para o fim: cada chave espera no máximo o trabalho em curso e um de cada outra chave
ativa, e não a fila inteira da outra. Por isso o timeout de espera precisa ser >= 2x o de execução.
- A vaga só é devolvida quando a thread realmente termina — mesmo que o cliente já tenha recebido 504 —,
para o limite de CPU ser real e não só aparente.
"""
from __future__ import annotations
import asyncio
from collections import deque
from collections.abc import Callable
from concurrent.futures import ThreadPoolExecutor
from typing import TypeVar
from .errors import QueueFull, QueueTimeout, SynthesisTimeout
T = TypeVar("T")
class WorkQueue:
def __init__(self, max_concurrency: int, max_queue_per_key: int, queue_timeout_s: float, run_timeout_s: float):
self.max_concurrency = max_concurrency
self.max_queue_per_key = max_queue_per_key
self.queue_timeout_s = queue_timeout_s
self.run_timeout_s = run_timeout_s
self._free = max_concurrency
# owner → esperas em ordem de chegada. A ordem do dict é o rodízio: quem é atendido vai para o fim.
self._waiters: dict[str, deque[asyncio.Future[None]]] = {}
self._executor = ThreadPoolExecutor(max_workers=max_concurrency, thread_name_prefix="work")
self.running = 0
@property
def waiting(self) -> int:
"""Total esperando, somadas todas as chaves."""
return sum(len(waiters) for waiters in self._waiters.values())
def waiting_for(self, owner: str) -> int:
waiters = self._waiters.get(owner)
return len(waiters) if waiters else 0
def is_full(self, owner: str) -> bool:
"""Verdadeiro quando um `run` novo DESTA chave seria recusado com QueueFull."""
return self._free == 0 and self.waiting_for(owner) >= self.max_queue_per_key
async def _acquire(self, owner: str) -> None:
if self._free > 0 and not self._waiters:
self._free -= 1
return
waiter: asyncio.Future[None] = asyncio.get_running_loop().create_future()
self._waiters.setdefault(owner, deque()).append(waiter)
try:
# asyncio.wait não cancela o future no timeout: dá para ver se a vaga chegou no último instante.
await asyncio.wait({waiter}, timeout=self.queue_timeout_s)
except BaseException: # cliente desistiu (CancelledError) enquanto esperava
self._abandon(owner, waiter)
raise
if not waiter.done():
self._abandon(owner, waiter)
raise QueueTimeout()
def _abandon(self, owner: str, waiter: asyncio.Future[None]) -> None:
if waiter.done() and not waiter.cancelled():
self._release() # a vaga já tinha sido entregue a esta espera: passa adiante
return
waiter.cancel()
waiters = self._waiters.get(owner)
if waiters is not None:
try:
waiters.remove(waiter)
except ValueError:
pass
if not waiters:
del self._waiters[owner]
def _release(self, finished_owner: str | None = None) -> None:
"""Entrega a vaga à próxima chave do rodízio; sem ninguém esperando, ela volta a ficar livre."""
if finished_owner is not None and finished_owner in self._waiters and len(self._waiters) > 1:
self._waiters[finished_owner] = self._waiters.pop(finished_owner) # quem acabou de rodar vai para o fim
while self._waiters:
owner = next(iter(self._waiters))
waiters = self._waiters.pop(owner)
waiter = waiters.popleft()
if waiters:
self._waiters[owner] = waiters # volta para o fim do rodízio
if not waiter.done():
waiter.set_result(None)
return
self._free += 1
async def run(self, fn: Callable[[], T], owner: str) -> T:
if self.is_full(owner):
raise QueueFull()
await self._acquire(owner)
self.running += 1
future = asyncio.get_running_loop().run_in_executor(self._executor, fn)
released = False
def _finish(_: object = None) -> None:
self.running -= 1
self._release(owner)
try:
return await asyncio.wait_for(asyncio.shield(future), timeout=self.run_timeout_s)
except asyncio.TimeoutError:
future.add_done_callback(_finish)
released = True
raise SynthesisTimeout() from None
except asyncio.CancelledError:
# Cliente desistiu no meio: a thread segue, então a vaga só volta quando ela terminar.
future.add_done_callback(_finish)
released = True
raise
finally:
if not released:
_finish()
def shutdown(self) -> None:
self._executor.shutdown(wait=False, cancel_futures=True)