"""Rotas do editor de cortes (`/v1/clips/{id}/edit|proxy|waveform|export|preview-render|retranscribe|tts|suggest`) e o render do projeto chamado pela fila do motor (worker.render_clip). O projeto fica na tabela `edits` (migração v4): `project_json` + `rev` (sobe a cada gravação; o painel manda o `rev` que leu e recebe 409 se outro lugar salvou no meio — autosave sem atropelar). Arquivos de trabalho do editor em `output/clipper//edit-/` (proxy 480p, forma de onda, narração TTS, prévia real). """ from __future__ import annotations import hashlib import json import logging import threading import time import uuid from pathlib import Path import httpx from fastapi import FastAPI, Request from fastapi.responses import JSONResponse from pydantic import BaseModel, Field from . import editor, editor_render, layout, media, speakers from .config import REPO_ROOT from .db import loads, now from .judge import JudgeError, _chat_block, _transcript from .scoring import Word log = logging.getLogger("cenaforge_clipper.editor") PREVIEW_MAX_S = 10.0 RETRANSCRIBE_MAX_S = 90.0 _locks: dict[str, threading.Lock] = {} _locks_guard = threading.Lock() def _lock(key: str) -> threading.Lock: with _locks_guard: return _locks.setdefault(key, threading.Lock()) class EditPut(BaseModel): project: dict rev: int = Field(default=0, ge=0) class WindowIn(BaseModel): lo: float = Field(ge=0) hi: float = Field(ge=0) class PreviewRenderIn(BaseModel): fromS: float = Field(default=0, ge=0, le=editor.MAX_OUTPUT_S) durationS: float = Field(default=5, ge=1, le=PREVIEW_MAX_S) project: dict | None = None # projeto ainda não salvo (o que está na tela); None = o salvo class RangeIn(BaseModel): startS: float = Field(ge=0) endS: float = Field(ge=0) class TtsIn(BaseModel): text: str = Field(min_length=1, max_length=300) voice: str = Field(pattern=r"^[a-z0-9][a-z0-9-]{1,47}$") speed: float = Field(default=1.0, ge=0.5, le=2.0) class SuggestIn(BaseModel): project: dict | None = None # ---------------------------------------------------------------- utilidades (também usadas pelo worker) def edit_dir(engine, session_id: int, clip_id: int) -> Path: return engine.settings.clips_dir / str(session_id) / f"edit-{clip_id}" def session_segments(engine, session_id: int) -> list[tuple[Path, float, float]]: return [(REPO_ROOT / s["file"], s["start_s"], s["end_s"]) for s in engine.db.all("SELECT * FROM segments WHERE session_id = ? AND deleted = 0 ORDER BY idx", session_id)] def validate_for(engine, clip: dict, session: dict, data: dict) -> dict: return editor.validate_project( data, session_id=clip["session_id"], session_duration=session["duration_s"], repo_root=REPO_ROOT, tts_dir=edit_dir(engine, clip["session_id"], clip["id"]), assets_dir=REPO_ROOT / "assets") def load_edit(engine, clip_id: int) -> dict | None: row = engine.db.get("SELECT * FROM edits WHERE clip_id = ?", clip_id) if row: row["project"] = loads(row["project_json"], None) return row def render_clip_edit(engine, clip: dict, session: dict, edit: dict, out: Path, thumb: Path) -> str | None: """Render do corte pelo projeto de edição (chamado pela fila do motor). Devolve o caminho da capa (ou None).""" project = validate_for(engine, clip, session, edit["project"]) segments = session_segments(engine, clip["session_id"]) if engine._encoder is None: engine._encoder = media.pick_encoder(engine.settings.ffmpeg or "ffmpeg", engine.settings.encoder) base = engine.intel.settings_for(session) credit = engine.channel_label(session) ffmpeg = engine.settings.ffmpeg or "ffmpeg" # A capa sai ANTES do vídeo: com `cover.atStart` ela também entra nos 2 primeiros quadros do MP4. cover: Path | None = None if project["cover"]["enabled"]: cover = out.parent / f"{out.stem}-cover.jpg" try: editor_render.render_cover(ffmpeg, segments, project, base, credit, cover) except media.MediaError as exc: # capa é extra: o vídeo vale mesmo sem ela log.warning("capa do corte %s falhou: %s", clip["id"], exc) cover = None editor_render.render_project(ffmpeg, engine.settings.ffprobe, engine._encoder, segments, project, base, credit, out, REPO_ROOT, chat=chat_for(engine, project), cover_file=cover, translation=translation_for(engine, clip, project, base)) total = editor.output_duration(project["cuts"]) media.thumbnail(ffmpeg, out, min(3.0, total / 2), thumb) # Formato em que ESTE arquivo saiu (camadas padrão ← canal ← sessão ← projeto): a fila desenha o player por ele. engine.db.run("UPDATE clips SET aspect = ? WHERE id = ?", layout.aspect(editor.effective_settings(base, project)), clip["id"]) return cover.relative_to(REPO_ROOT).as_posix() if cover else None def translation_for(engine, clip: dict, project: dict, base: dict, dev: bool = True) -> list[dict] | None: """Frases traduzidas para a legenda de desenvolvimento (doc/clipador/IDIOMAS.md): só com `dev.translation` ligado, render de desenvolvimento e fonte em inglês. Traduz o trecho do projeto se ainda não houver tradução.""" cfg = editor.effective_settings(base, project) if not layout.dev_flags(cfg, dev)["translation"]: return None ps = editor.pieces(project["cuts"]) if not ps: return None data = engine.translate_clip(clip["id"], ps[0].start, ps[-1].end) return (data or {}).get("lines") or None def chat_for(engine, project: dict) -> list | None: """Mensagens do chat da sessão para o bloco "chat na tela" (só quando o projeto pede).""" if not (project.get("chat") or {}).get("enabled"): return None lo = project["source"]["lo"] return engine.load_timeline(project["source"]["sessionId"], max(0.0, lo - 30))["chat"] def _judge(clip: dict) -> dict: data = loads(clip.get("judge_json"), None) return data if isinstance(data, dict) else {} def auto_for(engine, clip: dict, session: dict) -> dict: """Projeto que a IA entrega: o que o pipeline já sabe (análise, Whisper, volume, configuração do corte).""" judge = _judge(clip) lo, hi = editor.default_window(clip, session["duration_s"]) words = engine.words_between(clip["session_id"], lo, hi) # já com quem fala cada palavra (FALANTES.md) loudness = engine.load_timeline(clip["session_id"], max(0.0, lo - 5))["loudness"] return editor.auto_project(clip, judge.get("analysis"), words, loudness, session["duration_s"], engine.intel.settings_for(session), model=judge.get("model") or "", generated_at=now()) def ensure_edit(engine, clip: dict, session: dict) -> dict: """Garante o projeto de edição do corte (um só caminho de render: projeto → FFmpeg). Sem projeto, a IA gera um agora e ele fica salvo como "gerado pela IA". O trecho do corte (start/end) passa a ser o do projeto.""" row = load_edit(engine, clip["id"]) if row and row["project"]: return row project = validate_for(engine, clip, session, auto_for(engine, clip, session)) raw = json.dumps(project, ensure_ascii=False) ts = now() engine.db.run("INSERT OR REPLACE INTO edits (clip_id, project_json, origin, ai_project_json, rev, created_at, updated_at)" " VALUES (?, ?, 'ai', ?, 1, ?, ?)", clip["id"], raw, raw, ts, ts) start, end = editor.span(project) engine.db.run("UPDATE clips SET start_s = ?, end_s = ? WHERE id = ?", start, end, clip["id"]) return load_edit(engine, clip["id"]) def retime_edit(engine, clip_id: int, start: float, end: float) -> None: """O cartão mudou início/fim de um corte com edição: estica/encolhe as pontas do projeto.""" row = load_edit(engine, clip_id) if not row or not row["project"]: return project = editor.retime(row["project"], start, end) engine.db.run("UPDATE edits SET project_json = ?, rev = rev + 1, updated_at = ? WHERE clip_id = ?", json.dumps(project, ensure_ascii=False), now(), clip_id) def _audio_library() -> list[dict]: root = REPO_ROOT / "assets" out = [] if root.is_dir(): for f in sorted(root.rglob("*")): if f.is_file() and f.suffix.lower() in editor.AUDIO_EXT: out.append({"file": f.relative_to(REPO_ROOT).as_posix(), "name": f.stem}) if len(out) >= 200: break return out def _window_key(lo: float, hi: float) -> str: return f"{int(round(lo * 1000))}-{int(round(hi * 1000))}" def _clean_old(folder: Path, prefix: str, keep: str) -> None: for f in folder.glob(f"{prefix}-*"): if f.name != keep: f.unlink(missing_ok=True) # ---------------------------------------------------------------- rotas def register(app: FastAPI, engine, clip_view, get_clip) -> None: """`clip_view(row)` e `get_clip(id)` vêm do main (mesmo formato do resto da API; 404 se não existir).""" db, settings = engine.db, engine.settings ffmpeg = settings.ffmpeg or "ffmpeg" @app.exception_handler(editor.EditError) async def edit_error(_request: Request, exc: editor.EditError): return JSONResponse({"error": str(exc)}, status_code=400) @app.exception_handler(media.MediaError) async def media_error(_request: Request, exc: media.MediaError): return JSONResponse({"error": f"FFmpeg: {exc}"}, status_code=400) def _context(clip_id: int) -> tuple[dict, dict]: clip = get_clip(clip_id) session = db.get("SELECT * FROM sessions WHERE id = ?", clip["session_id"]) if not session: raise editor.EditError("sessão do corte não existe mais") return clip, session def _check_window(session: dict, lo: float, hi: float) -> tuple[float, float]: lo, hi = max(0.0, lo), min(hi, session["duration_s"]) if not 5 <= hi - lo <= editor.MAX_WINDOW_S: raise editor.EditError(f"a janela precisa ter de 5 s a {editor.MAX_WINDOW_S / 60:.0f} min dentro da gravação") segs = db.all("SELECT deleted FROM segments WHERE session_id = ? AND end_s > ? AND start_s < ?", session["id"], lo, hi) if not segs: raise editor.EditError("não há gravação nessa janela") if any(s["deleted"] for s in segs): raise editor.EditError("parte dessa janela já foi apagada (CLIPPER_KEEP_HOURS); escolha uma janela menor") return round(lo, 3), round(hi, 3) def _words(session_id: int, lo: float, hi: float) -> list[Word]: return [w for w in engine.words_between(session_id, lo, hi) if lo <= w.start <= hi] def _cached_proxy(clip: dict, lo: float, hi: float) -> dict | None: f = edit_dir(engine, clip["session_id"], clip["id"]) / f"proxy-{_window_key(lo, hi)}.mp4" return {"file": f.relative_to(REPO_ROOT).as_posix(), "lo": lo, "hi": hi} if f.is_file() else None def _cached_wave(clip: dict, lo: float, hi: float) -> list[float] | None: f = edit_dir(engine, clip["session_id"], clip["id"]) / f"waveform-{_window_key(lo, hi)}.json" return loads(f.read_text(encoding="utf-8"), None) if f.is_file() else None @app.get("/v1/clips/{clip_id}/edit") def get_edit(clip_id: int, lo: float | None = None, hi: float | None = None): """Tudo que o editor precisa: projeto (salvo ou o padrão), palavras/chat/volume da janela, análise da IA, configuração efetiva, presets, biblioteca de áudio e o que já está pronto (proxy, forma de onda).""" clip, session = _context(clip_id) row = load_edit(engine, clip_id) view = clip_view(clip) if row and row["project"]: project, rev = row["project"], row["rev"] ai_project = loads(row.get("ai_project_json"), None) else: project = ai_project = auto_for(engine, clip, session) # o que a IA entregaria (ainda não salvo) rev = 0 w_lo = project["source"]["lo"] if lo is None else lo w_hi = project["source"]["hi"] if hi is None else hi w_lo, w_hi = _check_window(session, w_lo, w_hi) tl = engine.load_timeline(clip["session_id"], max(0.0, w_lo - 5)) chat = [{"t": round(m.t, 2), "user": m.user, "text": m.text[:160], "emotes": list(m.emotes)} for m in tl["chat"] if w_lo <= m.t <= w_hi][:600] per_s = [0] * int(w_hi - w_lo + 1) for m in tl["chat"]: if w_lo <= m.t <= w_hi: per_s[int(m.t - w_lo)] += 1 loud = tl["loudness"][int(w_lo): int(w_hi) + 1] analysis = (view["judge"] or {}).get("analysis") if isinstance(view["judge"], dict) else None return { "clip": view, "project": project, "rev": rev, "saved": bool(row), "origin": row["origin"] if row else "ai", "aiProject": ai_project, "exportedAt": row["exported_at"] if row else None, "cover": row["cover"] if row else None, "window": {"lo": w_lo, "hi": w_hi}, "sessionDurationS": session["duration_s"], "words": [editor.word_item(w) for w in _words(clip["session_id"], w_lo, w_hi)], "chat": chat, "chatPerS": per_s, "loudnessDb": loud, "analysis": analysis, "settings": engine.intel.settings_for(session), "credit": engine.channel_label(session), "presets": [{"id": k, "label": editor.PRESET_LABEL[k], "style": editor.PRESET_STYLE[k]} for k in editor.CAPTION_PRESETS], "audioLibrary": _audio_library(), "proxy": _cached_proxy(clip, w_lo, w_hi), "waveform": _cached_wave(clip, w_lo, w_hi), "peaksPerS": editor_render.PEAKS_PER_S, "judgeEnabled": engine.judge.enabled, "voiceConfigured": engine.voice.configured, "limits": {"maxWindowS": editor.MAX_WINDOW_S, "maxOutputS": editor.MAX_OUTPUT_S, "minOutputS": editor.MIN_OUTPUT_S, "previewMaxS": PREVIEW_MAX_S, "retranscribeMaxS": RETRANSCRIBE_MAX_S}, } @app.put("/v1/clips/{clip_id}/edit") def put_edit(clip_id: int, body: EditPut): """Salva o projeto (autosave). `rev` = o que o painel leu; diferente do banco → 409 (outro salvou antes).""" clip, session = _context(clip_id) project = validate_for(engine, clip, session, body.project) ts = now() with db.lock: row = db.get("SELECT rev FROM edits WHERE clip_id = ?", clip_id) if row and body.rev != row["rev"]: return JSONResponse({"error": "O projeto foi salvo em outro lugar. Recarregue o editor.", "rev": row["rev"]}, status_code=409) if row: db.run("UPDATE edits SET project_json = ?, origin = 'user', rev = rev + 1, updated_at = ? WHERE clip_id = ?", json.dumps(project, ensure_ascii=False), ts, clip_id) else: ai = json.dumps(auto_for(engine, clip, session), ensure_ascii=False) db.run("INSERT INTO edits (clip_id, project_json, origin, ai_project_json, rev, created_at, updated_at)" " VALUES (?, ?, 'user', ?, 1, ?, ?)", clip_id, json.dumps(project, ensure_ascii=False), ai, ts, ts) rev = db.get("SELECT rev FROM edits WHERE clip_id = ?", clip_id)["rev"] return {"project": project, "rev": rev, "savedAt": ts, "durationS": editor.output_duration(project["cuts"])} @app.delete("/v1/clips/{clip_id}/edit", status_code=204) def delete_edit(clip_id: int): """Descarta a edição: o corte volta a ser renderizado do jeito automático (o MP4 atual fica até o próximo render).""" get_clip(clip_id) db.run("DELETE FROM edits WHERE clip_id = ?", clip_id) @app.post("/v1/clips/{clip_id}/proxy") def make_proxy(clip_id: int, body: WindowIn): """Vídeo leve (480p) da janela para a prévia no navegador. Fica em cache por janela.""" clip, session = _context(clip_id) lo, hi = _check_window(session, body.lo, body.hi) folder = edit_dir(engine, clip["session_id"], clip_id) name = f"proxy-{_window_key(lo, hi)}.mp4" with _lock(f"proxy-{clip_id}"): if not (folder / name).is_file(): t = time.monotonic() editor_render.make_proxy(ffmpeg, session_segments(engine, clip["session_id"]), lo, hi, folder / name) log.info("proxy do corte %s (%.0f s de vídeo) em %.1f s", clip_id, hi - lo, time.monotonic() - t) _clean_old(folder, "proxy", name) return _cached_proxy(clip, lo, hi) | {"words": [editor.word_item(w) for w in _words(clip["session_id"], lo, hi)]} @app.get("/v1/clips/{clip_id}/waveform") def get_waveform(clip_id: int, lo: float, hi: float): clip, session = _context(clip_id) lo, hi = _check_window(session, lo, hi) folder = edit_dir(engine, clip["session_id"], clip_id) name = f"waveform-{_window_key(lo, hi)}.json" with _lock(f"wave-{clip_id}"): peaks = _cached_wave(clip, lo, hi) if peaks is None: peaks = editor_render.waveform(ffmpeg, session_segments(engine, clip["session_id"]), lo, hi, folder) folder.mkdir(parents=True, exist_ok=True) (folder / name).write_text(json.dumps(peaks), encoding="utf-8") _clean_old(folder, "waveform", name) return {"lo": lo, "hi": hi, "peaksPerS": editor_render.PEAKS_PER_S, "peaks": peaks} @app.post("/v1/clips/{clip_id}/preview-render") def preview_render(clip_id: int, body: PreviewRenderIn): """Prévia REAL (mesma pipeline do export) de poucos segundos, a partir de `fromS` do corte editado.""" clip, session = _context(clip_id) row = load_edit(engine, clip_id) data = body.project or (row["project"] if row else None) if not data: raise editor.EditError("salve o projeto antes (ou mande o projeto na prévia)") project = validate_for(engine, clip, session, data) total = editor.output_duration(project["cuts"]) a = min(body.fromS, max(0.0, total - 1)) b = min(total, a + body.durationS) out = edit_dir(engine, clip["session_id"], clip_id) / "preview.mp4" segments = session_segments(engine, clip["session_id"]) base, credit = engine.intel.settings_for(session), engine.channel_label(session) with _lock(f"preview-{clip_id}"): t = time.monotonic() # Prévia que começa no 0 s com `cover.atStart`: a capa entra nos 2 primeiros quadros, como no export. cover = None if a <= 0.001 and project["cover"]["enabled"] and project["cover"].get("atStart"): cover = out.parent / "preview-cover.jpg" try: editor_render.render_cover(ffmpeg, segments, project, base, credit, cover) except media.MediaError as exc: # capa é extra: a prévia vale mesmo sem ela log.warning("capa da prévia do corte %s falhou: %s", clip_id, exc) cover = None editor_render.render_project(ffmpeg, settings.ffprobe, ["-c:v", "libx264", "-preset", "veryfast", "-crf", "24"], segments, project, base, credit, out, REPO_ROOT, out_range=(a, b), timeout=180, chat=chat_for(engine, project), cover_file=cover, translation=translation_for(engine, clip, project, base)) took = time.monotonic() - t return {"file": out.relative_to(REPO_ROOT).as_posix(), "fromS": a, "toS": b, "seconds": round(took, 1), "version": now()} @app.post("/v1/clips/{clip_id}/export") def export(clip_id: int): """Exporta: o corte volta para a fila de render com o projeto salvo; ao terminar fica `ready` (para aprovar).""" clip, session = _context(clip_id) row = load_edit(engine, clip_id) if not row or not row["project"]: raise editor.EditError("nada para exportar: salve o projeto primeiro") project = validate_for(engine, clip, session, row["project"]) start, end = editor.span(project) segs = db.all("SELECT deleted FROM segments WHERE session_id = ? AND end_s > ? AND start_s < ?", clip["session_id"], start, end) if not segs or any(s["deleted"] for s in segs): raise editor.EditError("os blocos gravados deste trecho já foram apagados") words = editor.output_words(project) ts = now() db.run("UPDATE clips SET start_s = ?, end_s = ?, status = 'pending', error = NULL, transcript = ?, updated_at = ? WHERE id = ?", start, end, " ".join(w.word for w in words)[:4000], ts, clip_id) db.run("UPDATE edits SET exported_at = ? WHERE clip_id = ?", ts, clip_id) engine.wake_clips.set() return clip_view(get_clip(clip_id)) | {"editedDurationS": editor.output_duration(project["cuts"])} @app.post("/v1/clips/{clip_id}/retranscribe") def retranscribe(clip_id: int, body: RangeIn): """Transcreve de novo (Whisper do serviço de voz, palavra a palavra) o trecho [startS, endS] da sessão.""" clip, session = _context(clip_id) a, b = body.startS, min(body.endS, session["duration_s"]) if not 0.5 <= b - a <= RETRANSCRIBE_MAX_S: raise editor.EditError(f"o trecho precisa ter de 0,5 a {RETRANSCRIBE_MAX_S:.0f} s") if not engine.voice.configured: raise editor.EditError("serviço de voz não instalado") wav = editor_render.extract_wav(ffmpeg, session_segments(engine, clip["session_id"]), a, b, edit_dir(engine, clip["session_id"], clip_id)) t = time.monotonic() try: words = engine.voice.transcribe(wav, f"clipper-edit-{clip_id}-{uuid.uuid4().hex[:12]}") except Exception as exc: # noqa: BLE001 - erro do serviço de voz vira mensagem raise editor.EditError(f"transcrição falhou: {str(exc)[:200]}") from exc # Quem fala: o mesmo das palavras antigas no mesmo instante (a re-transcrição não sabe o falante). fresh = speakers.transfer([Word(round(w.start + a, 3), round(w.end + a, 3), w.word) for w in words], _words(clip["session_id"], a - 1, b + 1)) return {"startS": a, "endS": b, "seconds": round(time.monotonic() - t, 1), "words": [editor.word_item(w) for w in fresh]} @app.post("/v1/clips/{clip_id}/tts") def tts(clip_id: int, body: TtsIn): """Narração pelo serviço de voz (WAV, para mixar sem perda). Guarda em edit-/tts-.wav.""" clip, _session = _context(clip_id) voice = engine.voice if not voice.configured: raise editor.EditError("serviço de voz não instalado") text = editor.CONTROL_RE.sub(" ", body.text).strip() digest = hashlib.sha256(f"{body.voice}|{body.speed:.2f}|{text}".encode("utf-8")).hexdigest()[:12] folder = edit_dir(engine, clip["session_id"], clip_id) out = folder / f"tts-{digest}.wav" if not out.is_file(): try: response = httpx.post(f"{voice.url}/v1/synthesize", timeout=300, headers={"X-Service-Key": voice.key or ""}, json={"requestId": f"clipper-{uuid.uuid4().hex[:24]}", "text": text, "voiceId": body.voice, "params": {"speed": body.speed, "format": "wav"}}) except httpx.HTTPError as exc: raise editor.EditError("serviço de voz fora do ar (127.0.0.1:4510)") from exc if response.status_code != 200: try: detail = response.json().get("error") or response.json().get("detail") or response.text except ValueError: detail = response.text raise editor.EditError(f"voz respondeu {response.status_code}: {str(detail)[:200]}") folder.mkdir(parents=True, exist_ok=True) out.write_bytes(response.content) duration = media.probe_duration(settings.ffprobe, out) if settings.ffprobe else 0.0 return {"file": out.relative_to(REPO_ROOT).as_posix(), "durationS": round(duration, 3), "text": text, "voice": body.voice} @app.post("/v1/clips/{clip_id}/suggest") def suggest(clip_id: int, body: SuggestIn): """IA sugere gancho, título, início/fim ideais, trechos mortos para remover e instantes de zoom.""" clip, session = _context(clip_id) if not engine.judge.enabled: raise editor.EditError("IA desligada (página Clipador → Juiz)") row = load_edit(engine, clip_id) data = body.project or (row["project"] if row else None) or editor.default_project( clip, [], session["duration_s"]) project = validate_for(engine, clip, session, data) lo, hi = project["source"]["lo"], project["source"]["hi"] tl = engine.load_timeline(clip["session_id"], max(0.0, lo - 5)) words = [Word(w["s"], w["e"], w["w"], w.get("sp") or "") for w in project["captions"]["words"]] or tl["words"] view = clip_view(clip) analysis = (view["judge"] or {}).get("analysis") if isinstance(view["judge"], dict) else None cfg = editor.effective_settings(engine.intel.settings_for(session), project) prompt = editor.suggest_prompt(engine.streamer_name(session), clip["title"], project, tl["chat"], analysis, _transcript(words, lo, hi, streamer=engine.streamer_name(session)), _chat_block(tl["chat"], lo, hi, clip["peak_s"]), cfg) t = time.monotonic() try: raw = engine.judge.ask(editor.SUGGEST_SYSTEM, prompt, editor.SUGGEST_SCHEMA, []) except JudgeError as exc: raise editor.EditError(f"IA: {exc}") from exc # Sugestão da IA = caminho automático: mínimo + 1 s e máximo da configuração do corte. return editor.clean_suggestion(raw, lo, hi, layout.min_target(cfg), float(cfg["duration"]["maxS"])) | {"seconds": round(time.monotonic() - t, 1), "model": engine.judge.describe().get("model")}