Skip to content

OpenSenseNova/SenseNova-Skills / skills/sn-motion-html

sn-motion-html

Verified

Build continuous-shot motion-driven HTML stories from a subject or narrative, including research, story structure, consistent AI stills, Seedance scene and connector clips, interface styling, media normalization, and browser QA. Use for immersive journeys, timelines, product stories, fictional worlds, or other scene-based visual narratives whose camera should flow from beginning to end; not for ordinary autoplay video pages or general web apps.

scripts/seedance_pipeline.py

View on GitHub
#!/usr/bin/env python3
"""Generate normalized scene and connector clips from a motion-story manifest."""

from __future__ import annotations

import argparse
import base64
from concurrent.futures import ThreadPoolExecutor
import json
import mimetypes
import os
from pathlib import Path
import shutil
import subprocess
import sys
import time
from typing import Any
from urllib.error import HTTPError, URLError
from urllib.request import Request, urlopen


class NonRetryableArkError(RuntimeError):
    """An account or request error another identical attempt cannot fix."""


def load_dotenv(root: Path) -> None:
    path = root / ".env"
    if not path.exists():
        return
    for raw in path.read_text(encoding="utf-8").splitlines():
        line = raw.strip()
        if not line or line.startswith("#") or "=" not in line:
            continue
        key, value = line.split("=", 1)
        os.environ.setdefault(key.strip(), value.strip().strip("'\""))


def data_uri(path: Path) -> str:
    mime = mimetypes.guess_type(path.name)[0] or "image/png"
    encoded = base64.b64encode(path.read_bytes()).decode("ascii")
    return f"data:{mime};base64,{encoded}"


class ArkClient:
    def __init__(self, key: str, base_url: str) -> None:
        self.key = key
        self.base_url = base_url.rstrip("/")

    def request(self, method: str, path: str, payload: dict[str, Any] | None = None) -> dict[str, Any]:
        body = None if payload is None else json.dumps(payload).encode("utf-8")
        request = Request(
            f"{self.base_url}{path}",
            data=body,
            method=method,
            headers={
                "Authorization": f"Bearer {self.key}",
                "Content-Type": "application/json",
                "User-Agent": "sn-motion-html/1.0",
            },
        )
        try:
            with urlopen(request, timeout=120) as response:
                return json.loads(response.read().decode("utf-8"))
        except HTTPError as exc:
            detail = exc.read().decode("utf-8", errors="replace")
            fatal = ('"ModelNotOpen"', '"AccessDenied"', '"InvalidAuthentication"', '"InvalidParameter"')
            error_type = NonRetryableArkError if any(code in detail for code in fatal) else RuntimeError
            raise error_type(f"Ark HTTP {exc.code}: {detail[:800]}") from exc
        except URLError as exc:
            raise RuntimeError(f"Ark network error: {exc.reason}") from exc

    def create(self, payload: dict[str, Any]) -> str:
        result = self.request("POST", "/contents/generations/tasks", payload)
        if not result.get("id"):
            raise RuntimeError(f"Ark response missing task id: {result}")
        return str(result["id"])

    def wait(self, task_id: str, poll_seconds: int, timeout_seconds: int) -> dict[str, Any]:
        deadline = time.monotonic() + timeout_seconds
        while time.monotonic() < deadline:
            result = self.request("GET", f"/contents/generations/tasks/{task_id}")
            status = str(result.get("status", ""))
            print(f"  {task_id}: {status or 'unknown'}", flush=True)
            if status == "succeeded":
                return result
            if status in {"failed", "cancelled", "expired"}:
                raise RuntimeError(f"Ark task {task_id} ended as {status}: {result}")
            time.sleep(poll_seconds)
        raise TimeoutError(f"Ark task {task_id} timed out after {timeout_seconds}s")


def download(url: str, path: Path) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    request = Request(url, headers={"User-Agent": "sn-motion-html/1.0"})
    with urlopen(request, timeout=180) as response, path.open("wb") as target:
        shutil.copyfileobj(response, target)


def run_ffmpeg(args: list[str]) -> None:
    subprocess.run(["ffmpeg", "-v", "error", "-y", *args], check=True)


def normalize_video(source: Path, target: Path, manifest: dict[str, Any]) -> None:
    target.parent.mkdir(parents=True, exist_ok=True)
    width = int(manifest.get("target_width", 1280))
    height = int(manifest.get("target_height", 720))
    fps = int(manifest.get("fps", 24))
    duration = float(manifest.get("duration", 4))
    filters = (
        f"scale={width}:{height}:force_original_aspect_ratio=increase,"
        f"crop={width}:{height},fps={fps},"
        f"tpad=stop_mode=clone:stop_duration={duration},trim=duration={duration},"
        "setpts=PTS-STARTPTS"
    )
    if manifest.get("generate_audio", False):
        audio_args = ["-af", f"apad,atrim=duration={duration}", "-c:a", "aac", "-b:a", "192k"]
    else:
        audio_args = ["-an"]
    run_ffmpeg([
        "-i", str(source), *audio_args, "-vf", filters,
        "-c:v", "libx264", "-preset", "slow", "-crf", str(manifest.get("crf", 20)),
        "-pix_fmt", "yuv420p", "-g", str(manifest.get("gop", 8)),
        "-keyint_min", str(manifest.get("gop", 8)), "-sc_threshold", "0",
        "-movflags", "+faststart", str(target),
    ])


def extract_frames(video: Path, first: Path, last: Path) -> None:
    first.parent.mkdir(parents=True, exist_ok=True)
    run_ffmpeg(["-i", str(video), "-vf", "select=eq(n\\,0)", "-frames:v", "1", str(first)])
    run_ffmpeg(["-sseof", "-0.05", "-i", str(video), "-frames:v", "1", str(last)])


def build_payload(
    manifest: dict[str, Any], prompt: str, first: Path, last: Path | None
) -> dict[str, Any]:
    mode = manifest.get("conditioning_mode", "reference_images")
    first_role = "reference_image" if mode == "reference_images" else "first_frame"
    content: list[dict[str, Any]] = [
        {"type": "text", "text": prompt},
        {"type": "image_url", "image_url": {"url": data_uri(first)}, "role": first_role},
    ]
    if last is not None:
        last_role = "reference_image" if mode == "reference_images" else "last_frame"
        content.append({"type": "image_url", "image_url": {"url": data_uri(last)}, "role": last_role})
    payload: dict[str, Any] = {
        "model": os.getenv("SEEDANCE_MODEL") or manifest["model"],
        "content": content,
        "duration": int(manifest["duration"]),
        "resolution": manifest["resolution"],
        "ratio": manifest["ratio"],
        "generate_audio": bool(manifest.get("generate_audio", False)),
        "watermark": bool(manifest.get("watermark", False)),
    }
    if manifest.get("output_format"):
        payload["output_format"] = manifest["output_format"]
    return payload


def generate_clip(
    root: Path,
    client: ArkClient,
    manifest: dict[str, Any],
    kind: str,
    item: dict[str, Any],
    first: Path,
    last: Path | None,
    args: argparse.Namespace,
) -> None:
    clip_id = item["id"]
    output = root / item["output"]
    if output.exists() and output.stat().st_size > 0 and not args.force:
        print(f"skip {kind} {clip_id} (already exists)")
        return
    if not first.exists() or (last is not None and not last.exists()):
        raise FileNotFoundError(f"Missing conditioning frame for {clip_id}")

    prompt_path = root / item["prompt"]
    prompt = prompt_path.read_text(encoding="utf-8").strip()
    style_motion_path = root / "prompts" / "style-motion.txt"
    if style_motion_path.exists():
        style_motion = style_motion_path.read_text(encoding="utf-8").strip()
        if style_motion:
            prompt = f"{style_motion}\n\n{prompt}"
    raw = root / "tmp" / "seedance" / "raw" / kind / f"{clip_id}.mp4"
    tasks = root / "tmp" / "seedance" / "tasks"
    tasks.mkdir(parents=True, exist_ok=True)
    safe = {
        "model": os.getenv("SEEDANCE_MODEL") or manifest["model"],
        "kind": kind,
        "clip_id": clip_id,
        "prompt_file": item["prompt"],
        "first_frame": str(first.relative_to(root)),
        "last_frame": str(last.relative_to(root)) if last else None,
    }

    last_error: Exception | None = None
    for attempt in range(1, args.attempts + 1):
        print(f"{kind} {clip_id} attempt {attempt}/{args.attempts}", flush=True)
        try:
            task_id = client.create(build_payload(manifest, prompt, first, last))
            safe.update({"attempt": attempt, "task_id": task_id})
            (tasks / f"{kind}-{clip_id}-request.json").write_text(
                json.dumps(safe, ensure_ascii=False, indent=2), encoding="utf-8"
            )
            result = client.wait(task_id, args.poll_seconds, args.timeout_seconds)
            (tasks / f"{kind}-{clip_id}-result.json").write_text(
                json.dumps(result, ensure_ascii=False, indent=2), encoding="utf-8"
            )
            video_url = result.get("content", {}).get("video_url")
            if not video_url:
                raise RuntimeError(f"Succeeded task has no content.video_url: {task_id}")
            download(str(video_url), raw)
            normalize_video(raw, output, manifest)
            print(f"saved {output.relative_to(root)}", flush=True)
            return
        except Exception as exc:
            last_error = exc
            print(f"  failed: {exc}", file=sys.stderr, flush=True)
            if isinstance(exc, NonRetryableArkError):
                raise
    raise RuntimeError(f"{kind} {clip_id} failed after {args.attempts} attempts") from last_error


def run_dives(root: Path, client: ArkClient, manifest: dict[str, Any], args: argparse.Namespace) -> None:
    items = manifest.get("dives", [])[: args.limit or None]
    frames = root / "assets" / "video" / "frames"

    def run_one(item: dict[str, Any]) -> None:
        generate_clip(root, client, manifest, "dives", item, root / item["still"], None, args)
        output = root / item["output"]
        extract_frames(output, frames / f"{item['id']}-first.png", frames / f"{item['id']}-last.png")

    if items:
        with ThreadPoolExecutor(max_workers=min(args.workers, len(items))) as executor:
            list(executor.map(run_one, items))


def run_connectors(root: Path, client: ArkClient, manifest: dict[str, Any], args: argparse.Namespace) -> None:
    items = manifest.get("connectors", [])[: args.limit or None]
    frames = root / "assets" / "video" / "frames"

    def run_one(item: dict[str, Any]) -> None:
        generate_clip(
            root, client, manifest, "connectors", item,
            frames / f"{item['from']}-last.png", frames / f"{item['to']}-first.png", args,
        )

    if items:
        with ThreadPoolExecutor(max_workers=min(args.workers, len(items))) as executor:
            list(executor.map(run_one, items))


def main() -> int:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("project_root", type=Path)
    parser.add_argument("phase", choices=["plan", "dives", "connectors", "all"], nargs="?", default="plan")
    parser.add_argument("--workers", type=int, default=4)
    parser.add_argument("--attempts", type=int, default=2)
    parser.add_argument("--limit", type=int, default=0)
    parser.add_argument("--force", action="store_true")
    parser.add_argument("--poll-seconds", type=int, default=8)
    parser.add_argument("--timeout-seconds", type=int, default=1800)
    args = parser.parse_args()
    if args.workers < 1 or args.attempts < 1:
        parser.error("--workers and --attempts must be at least 1")

    root = args.project_root.expanduser().resolve()
    load_dotenv(root)
    manifest = json.loads((root / "prompts" / "video-manifest.json").read_text(encoding="utf-8"))
    plan = {
        "model": os.getenv("SEEDANCE_MODEL") or manifest["model"],
        "duration": manifest["duration"],
        "resolution": manifest["resolution"],
        "ratio": manifest["ratio"],
        "dives": len(manifest.get("dives", [])),
        "connectors": len(manifest.get("connectors", [])),
        "workers": args.workers,
        "conditioning_mode": manifest.get("conditioning_mode", "reference_images"),
    }
    print(json.dumps(plan, ensure_ascii=False, indent=2))
    if args.phase == "plan":
        return 0
    if shutil.which("ffmpeg") is None:
        raise SystemExit("ffmpeg is required")
    key = os.getenv("ARK_API_KEY") or os.getenv("VOLCENGINE_API_KEY")
    if not key:
        raise SystemExit("ARK_API_KEY is not set in the project-local .env file")
    client = ArkClient(key, os.getenv("ARK_BASE_URL", "https://ark.cn-beijing.volces.com/api/v3"))
    if args.phase in {"dives", "all"}:
        run_dives(root, client, manifest, args)
    if args.phase in {"connectors", "all"}:
        run_connectors(root, client, manifest, args)
    return 0


if __name__ == "__main__":
    raise SystemExit(main())
finishing-a-development-branchobra/superpowersUse when implementation is complete, all tests pass, and you need to decide how to integrate the workStars: 322kUpdated Claude CodeCodexVerifiedInstall
systematic-debuggingobra/superpowersUse when encountering any bug, test failure, or unexpected behavior, before proposing fixesStars: 322kUpdated Claude CodeCodexVerifiedInstall
test-driven-developmentobra/superpowersUse when implementing any feature or bugfix, before writing implementation codeStars: 322kUpdated Claude CodeCodexVerifiedInstall
skill-creatoranthropics/skillsCreate new skills, modify and improve existing skills, and measure skill performance. Use when users want to create a skill from scratch, edit, or optimize an existing skill, run evals to test a skill, benchmark skill performance with variance analysis, or optimize a skill's description for better triggering accuracy.Stars: 198kUpdated Claude CodeCodexVerifiedInstall