MMnode/bench/app/tracks.py
Z User eefca88d35 feat: Moxie bench - standalone python/web harness for the fixed pipeline
- bench/ FastAPI server: fixed 9-stage pipeline parsed from the base
  workflow, serial render jobs, WS progress mirroring ComfyUI's push
  events, /api/view + ComfyUI-compatible /view, /upload/image,
  /easy-media/* aliases for the ported editor
- dual backend: self-contained mock renderer (numpy+ffmpeg, deterministic
  per prompt/seed, native + RTX-upscaled mp4 branches) and a ComfyUI
  bridge (substitutes the plan into base_workflow.json, converts to the
  /prompt API format, polls history, downloads outputs)
- timeline port: frontend/src/bench mounts the unmodified MultiTrack
  editor against a comfyAPI shim (fetchApi/toast/dialog/custom events);
  build.bench.ts emits bench/ui-dist served by the server
- packaging: PyInstaller onedir spec + Tauri2 sidecar docs
- tests: bench/tests contract suite + scripts/test_bench_pipeline.py
  e2e (API+WS+render); prebuilt bench UI committed
2026-09-28 01:42:58 +00:00

196 lines
6.1 KiB
Python

"""track_data (the multitrack editor JSON) -> RenderPlan.
Pure extraction, no ComfyUI. Mirrors what ``MultiTrackEditor.execute`` feeds
into TRACKS_INFO for the fixed pipeline: task tracks carry the prompt segments
that become generation tasks; video/audio tracks carry media references.
"""
from __future__ import annotations
import json
from dataclasses import dataclass, field
from typing import Any
class TrackDataError(ValueError):
pass
@dataclass
class Segment:
id: str
start_frame: int
end_frame: int
prompt: str = ""
task_mode: str = "default"
continuity_mode: str = "shot"
ref_image_size: str = "match"
media_type: str = "none"
images: list[Any] = field(default_factory=list)
muted: bool = False
volume_db: float = 0.0
@property
def frame_count(self) -> int:
return max(0, self.end_frame - self.start_frame)
@dataclass
class Track:
id: str
name: str
type: str
task_mode: str = "default"
muted: bool = False
solo: bool = False
volume_db: float = 0.0
locked: bool = False
segments: list[Segment] = field(default_factory=list)
@dataclass
class RenderPlan:
width: int
height: int
frame_rate: int
total_length: int
segments: list[Segment] = field(default_factory=list) # ordered task segments
tracks: list[Track] = field(default_factory=list)
project_name: str = "MoxieBench"
steps: int = 4
seed: int = 0
lora: str | None = None
lora_strength: float = 1.0
upscale_width: int | None = None
upscale_height: int | None = None
upscale_quality: str = "ULTRA"
codec: str = "h264"
@property
def duration_seconds(self) -> float:
return self.total_length / float(self.frame_rate or 24)
def summary(self) -> dict[str, Any]:
return {
"width": self.width,
"height": self.height,
"frame_rate": self.frame_rate,
"total_length": self.total_length,
"duration_seconds": round(self.duration_seconds, 3),
"steps": self.steps,
"seed": self.seed,
"lora": self.lora,
"project_name": self.project_name,
"upscale": (
{"width": self.upscale_width, "height": self.upscale_height,
"quality": self.upscale_quality}
if self.upscale_width else None
),
"segments": [
{
"id": s.id,
"prompt": s.prompt,
"start_frame": s.start_frame,
"end_frame": s.end_frame,
"frame_count": s.frame_count,
"task_mode": s.task_mode,
"continuity_mode": s.continuity_mode,
}
for s in self.segments
],
}
def parse_track_data(raw: str | dict[str, Any]) -> dict[str, Any]:
if isinstance(raw, str):
try:
raw = json.loads(raw)
except json.JSONDecodeError as exc:
raise TrackDataError(f"track_data is not valid JSON: {exc}") from exc
if not isinstance(raw, dict):
raise TrackDataError("track_data must be an object")
if not isinstance(raw.get("tracks"), list):
raise TrackDataError("track_data.tracks must be a list")
return raw
def build_render_plan(
track_data: str | dict[str, Any],
*,
width: int,
height: int,
frame_rate: int | None = None,
steps: int = 4,
seed: int = 0,
project_name: str = "MoxieBench",
lora: str | None = None,
lora_strength: float = 1.0,
upscale_width: int | None = None,
upscale_height: int | None = None,
upscale_quality: str = "ULTRA",
codec: str = "h264",
) -> RenderPlan:
data = parse_track_data(track_data)
# Timeline fps: editor stores it on track_data.frame_rate (24 in the base
# workflow); the combine project_data may override it.
if frame_rate is None:
frame_rate = int(data.get("frame_rate") or 24)
total = int(data.get("total_length") or 0)
tracks: list[Track] = []
segments: list[Segment] = []
for t in data["tracks"]:
if not isinstance(t, dict):
continue
track = Track(
id=str(t.get("id", "")),
name=str(t.get("name", "")),
type=str(t.get("type", "task")),
task_mode=str(t.get("task_mode", "default")),
muted=bool(t.get("muted", False)),
solo=bool(t.get("solo", False)),
volume_db=float(t.get("volume_db", 0)),
locked=bool(t.get("locked", False)),
)
for seg in t.get("segments") or []:
if not isinstance(seg, dict):
continue
content = seg.get("content") or {}
s = Segment(
id=str(seg.get("id", "")),
start_frame=int(seg.get("start_frame", 0)),
end_frame=int(seg.get("end_frame", 0)),
prompt=str(content.get("user_prompt", "") or ""),
task_mode=str(content.get("task_mode", track.task_mode or "default")),
continuity_mode=str(content.get("continuity_mode", "shot")),
ref_image_size=str(content.get("ref_image_size", "match")),
media_type=str(content.get("media_type", "none")),
images=list(content.get("images") or []),
muted=bool(content.get("muted", False)),
volume_db=float(content.get("volume_db", 0)),
)
track.segments.append(s)
if track.type == "task" and s.frame_count > 0:
segments.append(s)
tracks.append(track)
segments.sort(key=lambda s: (s.start_frame, s.end_frame))
return RenderPlan(
width=int(width),
height=int(height),
frame_rate=int(frame_rate),
total_length=total,
segments=segments,
tracks=tracks,
project_name=str(project_name),
steps=int(steps),
seed=int(seed),
lora=lora,
lora_strength=float(lora_strength),
upscale_width=upscale_width,
upscale_height=upscale_height,
upscale_quality=str(upscale_quality),
codec=str(codec),
)