flits-video 0.2.0__py3-none-any.whl

flits/__init__.py

@@ -0,0 +1,38 @@
+"""Python wrapper for flits, the fast GPU video renderer.
+
+Build a scene as a dict (typed with `flits.types.Scene`) and render it with the flits CLI:
+
+    import flits
+    scene = {"width": 1080, "height": 1920, "duration": 3,
+             "layers": [{"type": "text", "text": "Hello", "size": 120, "in": "pop"}]}
+    print(flits.check(scene))
+    flits.render(scene, "hello.mp4", scale=0.5)
+
+The CLI is found via the `bin=` argument, $FLITS_BIN or PATH. Relative media paths in a scene dict resolve
+against `base_dir` (default: the current directory).
+"""
+
+from .compile import compile, flatten, sample
+from ._cli import CheckResult, FlitsError, binary, check, render, run, scene_file, schema, sheet, still, to_args, transcribe
+from .types import Layer, Scene
+
+__all__ = [
+    "compile",
+    "flatten",
+    "sample",
+    "CheckResult",
+    "FlitsError",
+    "Layer",
+    "Scene",
+    "binary",
+    "check",
+    "render",
+    "run",
+    "scene_file",
+    "schema",
+    "sheet",
+    "still",
+    "to_args",
+    "transcribe",
+]
+__version__ = "0.2.0"

flits/_cli.py

@@ -0,0 +1,230 @@
+"""Run the flits CLI from Python (subprocess; no other dependencies)."""
+
+import json
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+from contextlib import contextmanager
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Dict, Iterator, List, Mapping, Optional, Sequence, Union
+
+from .compile import compile
+
+PathLike = Union[str, "os.PathLike[str]"]
+SceneInput = Union[Mapping[str, Any], PathLike]
+"""A scene dict (see flits.types.Scene) or the path of a scene .json file."""
+
+
+class FlitsError(RuntimeError):
+    """flits failed (or could not be started; then returncode is None). `stderr`/`stdout` hold its output."""
+
+    def __init__(self, message: str, returncode: Optional[int] = None, stderr: str = "", args: Sequence[str] = (), stdout: str = ""):
+        super().__init__(message)
+        self.returncode = returncode
+        self.stderr = stderr
+        self.stdout = stdout
+        self.cmd = list(args)
+
+
+@dataclass
+class CheckResult:
+    """Outcome of `check`: ok means the scene loads and prepares (warnings don't make it fail)."""
+
+    ok: bool
+    warnings: List[str] = field(default_factory=list)
+    error: Optional[str] = None
+    output: str = ""
+
+
+def binary(bin: Optional[PathLike] = None) -> str:
+    """The flits executable: `bin`, $FLITS_BIN or `flits` on PATH."""
+    if bin is not None:
+        return os.fspath(bin)
+    env = os.environ.get("FLITS_BIN")
+    if env:
+        return env
+    found = shutil.which("flits")
+    if not found:
+        raise FlitsError("flits not found: install it (https://github.com/ArjandenHartog/flits) or set FLITS_BIN")
+    return found
+
+
+def to_args(options: Mapping[str, Any]) -> List[str]:
+    """{"keep_temp": True, "workers": 4} -> ["--keep-temp", "--workers", "4"]"""
+    args: List[str] = []
+    for key, value in options.items():
+        if value is None or value is False:
+            continue
+        flag = "--" + key.replace("_", "-")
+        if value is True:
+            args.append(flag)
+        elif isinstance(value, (list, tuple)):
+            for v in value:
+                args += [flag, str(v)]
+        else:
+            args += [flag, os.fspath(value) if isinstance(value, os.PathLike) else str(value)]
+    return args
+
+
+def run(args: Sequence[str], *, bin: Optional[PathLike] = None, echo: bool = False, cwd: Optional[PathLike] = None) -> str:
+    """Run `flits <args>` and return stdout. With echo=True, progress (stderr) is copied to sys.stderr live."""
+    cmd = [binary(bin), *map(str, args)]
+    try:
+        proc = subprocess.Popen(
+            cmd,
+            cwd=cwd,
+            stdin=subprocess.DEVNULL,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+        )
+    except FileNotFoundError as e:
+        raise FlitsError(f"flits not found ({cmd[0]}): install it or set FLITS_BIN") from e
+    if echo:
+        # stdout is small (paths, timelines); stream stderr, then collect stdout
+        err_parts: List[str] = []
+        stderr, stdout = proc.stderr, proc.stdout
+        assert stderr is not None and stdout is not None
+        for chunk in iter(lambda: stderr.read(256), ""):
+            err_parts.append(chunk)
+            sys.stderr.write(chunk)
+            sys.stderr.flush()
+        out = stdout.read()
+        proc.wait()
+        err = "".join(err_parts)
+    else:
+        out, err = proc.communicate()
+    if proc.returncode != 0:
+        lines = [line for line in err.splitlines() if line.startswith("error:")]
+        msg = lines[-1] if lines else f"flits exited with code {proc.returncode}"
+        raise FlitsError(msg, proc.returncode, err, cmd, out)
+    return out
+
+
+@contextmanager
+def scene_file(scene: SceneInput, base_dir: Optional[PathLike] = None) -> Iterator[str]:
+    """Yield the scene as a file path. A dict is written to a temporary file in `base_dir` (default: the current
+    directory) so relative media paths in it resolve against that folder; the file is removed afterwards."""
+    if not isinstance(scene, Mapping):
+        yield os.fspath(scene)
+        return
+    folder = Path(base_dir if base_dir is not None else os.getcwd()).resolve()
+    fd, path = tempfile.mkstemp(prefix=".flits-", suffix=".scene.json", dir=folder)
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8") as f:
+            json.dump(compile(dict(scene)), f, ensure_ascii=False, indent=1)
+        yield path
+    finally:
+        try:
+            os.remove(path)
+        except OSError:
+            pass
+
+
+def _lines(s: str) -> List[str]:
+    return [line.strip() for line in s.splitlines() if line.strip()]
+
+
+def render(
+    scene: SceneInput,
+    out: PathLike,
+    *,
+    base_dir: Optional[PathLike] = None,
+    bin: Optional[PathLike] = None,
+    echo: bool = False,
+    **options: Any,
+) -> Path:
+    """Render a scene to a video and return the output path.
+
+    options are `flits render` flags: workers, encoder ("auto"|"nvenc"|"qsv"|"vaapi"|"cpu"|"null"),
+    codec ("h264"|"hevc"|"av1"), speed ("fast"|"balanced"|"quality"), quality (18..28), scale (0.5 = preview),
+    gpu ("auto"|"gpu"|"cpu"), keep_temp, quiet, remote.
+    """
+    out = Path(out).resolve()
+    with scene_file(scene, base_dir) as path:
+        run(["render", path, "-o", str(out), *to_args(options)], bin=bin, echo=echo)
+    return out
+
+
+def still(
+    scene: SceneInput,
+    at: Union[float, str, Sequence[Union[float, str]]],
+    out: PathLike,
+    *,
+    scale: Optional[float] = None,
+    base_dir: Optional[PathLike] = None,
+    bin: Optional[PathLike] = None,
+) -> List[Path]:
+    """Render frame(s) at the given time(s) (seconds or "mm:ss") to PNG; returns the written files."""
+    times = list(at) if isinstance(at, (list, tuple)) else [at]
+    with scene_file(scene, base_dir) as path:
+        stdout = run(["still", path, *to_args({"at": times, "scale": scale}), "-o", str(Path(out).resolve())], bin=bin)
+    return [Path(p) for p in _lines(stdout)]
+
+
+def sheet(
+    scene: SceneInput,
+    out: PathLike,
+    *,
+    base_dir: Optional[PathLike] = None,
+    bin: Optional[PathLike] = None,
+    **options: Any,
+) -> Path:
+    """Contact sheet: evenly spaced frames in one PNG (options: count, cols, thumb)."""
+    out = Path(out).resolve()
+    with scene_file(scene, base_dir) as path:
+        run(["sheet", path, "-o", str(out), *to_args(options)], bin=bin)
+    return out
+
+
+def check(scene: SceneInput, *, base_dir: Optional[PathLike] = None, bin: Optional[PathLike] = None) -> CheckResult:
+    """Validate a scene the way flits sees it (typos, bad values, missing files). Does not raise for an invalid
+    scene: inspect `result.ok`, `result.error` and `result.warnings`."""
+    def warnings(output: str) -> List[str]:
+        return [line[len("warning: ") :] for line in _lines(output) if line.startswith("warning: ")]
+
+    with scene_file(scene, base_dir) as path:
+        try:
+            output = run(["check", path], bin=bin)
+        except FlitsError as e:
+            if e.returncode is None:
+                raise
+            msg = str(e)
+            error = msg[len("error: ") :] if msg.startswith("error: ") else msg
+            return CheckResult(ok=False, warnings=warnings(e.stdout), error=error, output=e.stdout + e.stderr)
+    return CheckResult(ok=True, warnings=warnings(output), output=output)
+
+
+def transcribe(
+    inputs: Union[PathLike, Sequence[PathLike]],
+    out: Optional[PathLike] = None,
+    *,
+    outdir: Optional[PathLike] = None,
+    model: Optional[str] = None,
+    lang: Optional[str] = None,
+    device: Optional[str] = None,
+    python: Optional[PathLike] = None,
+    remote: Optional[str] = None,
+    bin: Optional[PathLike] = None,
+    echo: bool = False,
+) -> List[Path]:
+    """Transcribe audio/video to word-timed JSON (+ .srt/.vtt/.txt next to it); returns the .words.json paths.
+
+    model: "default" (large-v3-turbo on GPU, small on CPU), "tiny", ... "large-v3-turbo"; lang: "en", "nl", ... or "auto";
+    device: "auto" | "cuda" | "cpu"; remote: GPU server URL or "off".
+    """
+    files = [inputs] if isinstance(inputs, (str, os.PathLike)) else list(inputs)
+    opts = {"out": out, "outdir": outdir, "model": model, "lang": lang, "device": device, "python": python, "remote": remote}
+    stdout = run(["transcribe", *[str(Path(f).resolve()) for f in files], *to_args(opts)], bin=bin, echo=echo)
+    return [Path(p) for p in _lines(stdout)]
+
+
+def schema(*, bin: Optional[PathLike] = None) -> Dict[str, Any]:
+    """The JSON Schema of the scene format, from the installed flits."""
+    result: Dict[str, Any] = json.loads(run(["schema"], bin=bin))
+    return result

flits/compile.py

@@ -0,0 +1,102 @@
+"""Plain scene JSON from a scene built in Python (mirrors bindings/typescript/compile.js).
+
+* Animatable properties may be callables ``f(t, ctx) -> float`` (``t`` = seconds since the layer started,
+  ``ctx`` = ``{"frame", "fps", "duration", "progress"}``); they are sampled once per frame into linear
+  keyframes, so any maths animates exactly as computed.
+* ``children``/``layers`` may be nested lists with ``None``/``False`` entries (dropped).
+"""
+
+import math
+from typing import Any, Callable, Dict, List, Optional
+
+ANIMATABLE = ("x", "y", "scale", "scaleX", "scaleY", "rotation", "opacity", "zoom", "panX", "panY", "value", "progress", "volume")
+
+
+def flatten(children: Any) -> List[Any]:
+    """Nested lists flattened; None, False and True dropped."""
+    out: List[Any] = []
+
+    def walk(c: Any) -> None:
+        if isinstance(c, (list, tuple)):
+            for x in c:
+                walk(x)
+        elif c is not None and c is not False and c is not True:
+            out.append(c)
+
+    walk(children)
+    return out
+
+
+def sample(fn: Callable[..., float], duration: Optional[float], fps: float, what: str = "property") -> List[list]:
+    """``fn`` sampled every frame over ``duration`` seconds as linear keyframes (straight stretches collapsed)."""
+    if duration is None or not duration > 0 or math.isinf(duration):
+        raise ValueError(f"{what}: a function needs to know how long the layer lasts: give it (or its group, or the scene) a duration")
+    n = max(1, math.ceil(duration * fps - 1e-9))
+    pts = []
+    for frame in range(n + 1):
+        t = min(frame / fps, duration)
+        v = fn(t, {"frame": frame, "fps": fps, "duration": duration, "progress": t / duration})
+        if not isinstance(v, (int, float)) or isinstance(v, bool) or not math.isfinite(v):
+            raise ValueError(f"{what}: the function returned {v!r} at t={t:.3f}s (expected a finite number)")
+        pts.append([round(t, 6), round(float(v), 6)])
+    keep = [pts[0]]
+    for i in range(1, len(pts) - 1):
+        a, b, c = keep[-1], pts[i], pts[i + 1]
+        lin = a[1] + (c[1] - a[1]) * (b[0] - a[0]) / (c[0] - a[0])
+        if abs(lin - b[1]) > 1e-4:
+            keep.append(b)
+    if len(pts) > 1:
+        keep.append(pts[-1])
+    return [k if i == 0 else [k[0], k[1], "linear"] for i, k in enumerate(keep)]
+
+
+def _lifetime(layer: Dict[str, Any], parent: Optional[float]) -> Optional[float]:
+    if isinstance(layer.get("duration"), (int, float)):
+        return layer["duration"]
+    if isinstance(layer.get("end"), (int, float)):
+        return layer["end"] - layer.get("start", 0)
+    if parent is not None:
+        return parent - layer.get("start", 0)
+    return None
+
+
+def _layer(layer: Any, parent: Optional[float], fps: float, path: str) -> Dict[str, Any]:
+    if not isinstance(layer, dict):
+        raise ValueError(f"{path}: expected a layer dict, got {type(layer).__name__}")
+    dur = _lifetime(layer, parent)
+    out: Dict[str, Any] = {}
+    for k, v in layer.items():
+        if v is None:
+            continue
+        if callable(v):
+            if k not in ANIMATABLE:
+                raise ValueError(f"{path}.{k}: only animatable properties ({', '.join(ANIMATABLE)}) can be functions")
+            out[k] = sample(v, dur, fps, f"{path}.{k}")
+        elif k == "children":
+            kids = flatten(v)
+            out[k] = [_layer(c, None if layer.get("sequence") else dur, fps, f"{path}.children[{i}]") for i, c in enumerate(kids)]
+        else:
+            out[k] = v
+    return out
+
+
+def compile(scene: Dict[str, Any]) -> Dict[str, Any]:
+    """Plain scene JSON: callables sampled, children flattened."""
+    if not isinstance(scene, dict):
+        raise ValueError("the scene must be a dict like {'width': ..., 'height': ..., 'layers': [...]}")
+    fps = scene.get("fps", 30)
+    out = {k: v for k, v in scene.items() if v is not None and k not in ("layers", "audio")}
+    out["layers"] = [_layer(l, scene.get("duration"), fps, f"layers[{i}]") for i, l in enumerate(flatten(scene.get("layers", [])))]
+    audio = flatten(scene.get("audio", []))
+    if audio:
+        tracks = []
+        for i, a in enumerate(audio):
+            a = dict(a)
+            if callable(a.get("volume")):
+                d = a.get("duration")
+                if d is None and scene.get("duration") is not None:
+                    d = scene["duration"] - a.get("start", 0)
+                a["volume"] = sample(a["volume"], d, fps, f"audio[{i}].volume")
+            tracks.append(a)
+        out["audio"] = tracks
+    return out

flits/types.py

@@ -0,0 +1,404 @@
+"""TypedDict definitions for the flits scene format.
+
+Mirrors schema/scene.schema.json (generated from the Rust structs with `flits schema`); the Rust test
+tests/schema.rs checks that every property and enum value of the schema appears here. These are plain
+dicts at runtime: use them for editor completion and type checking (mypy, pyright).
+
+Units are pixels (origin top-left) and seconds; relative paths resolve against the scene's folder.
+"""
+
+import sys
+from typing import Callable, Dict, List, Literal, Tuple, TypedDict, Union
+
+if sys.version_info >= (3, 11):
+    from typing import Required
+else:  # pragma: no cover
+    from typing_extensions import Required
+
+__all__ = [
+    "Color",
+    "Ease",
+    "KeyTime",
+    "Keyframe",
+    "FromTo",
+    "Animated",
+    "TransitionType",
+    "TransitionSpec",
+    "Transition",
+    "Duck",
+    "Padding",
+    "LayerType",
+    "Fit",
+    "Align",
+    "Reveal",
+    "Wrap",
+    "CaptionStyle",
+    "CaptionPreset",
+    "ShapeKind",
+    "LineCap",
+    "HighlightBox",
+    "TextBgMode",
+    "GradientType",
+    "Border",
+    "Shadow",
+    "StrokeSpec",
+    "TextBg",
+    "Filter",
+    "Gradient",
+    "AudioTrack",
+    "Layer",
+    "Scene",
+]
+
+# ------------------------------------------------------------------ values
+
+Color = str
+"""'#rgb', '#rgba', '#rrggbb', '#rrggbbaa', 'rgb(r,g,b)', 'rgba(r,g,b,a)' or a name:
+"white", "black", "transparent", "red", "green", "blue", "yellow", "orange", "purple", "pink", "gray", "grey"."""
+
+EaseName = Literal[
+    "linear",
+    "in",
+    "out",
+    "in-out",
+    "smooth",
+    "back-in",
+    "back-out",
+    "elastic",
+    "bounce",
+    "spring",
+    "hold",
+    "expo-in",
+    "expo-out",
+    "expo-in-out",
+    "quint-out",
+    "quint-in-out",
+    "circ-out",
+    # aliases
+    "ease-in",
+    "easein",
+    "ease-out",
+    "easeout",
+    "ease",
+    "inout",
+    "ease-in-out",
+    "easeinout",
+    "sine",
+    "sine-in-out",
+    "anticipate",
+    "back",
+    "overshoot",
+    "step",
+    "expo",
+    "quint",
+    "circ",
+]
+Ease = Union[EaseName, str]
+"""An easing name, or a CSS curve as the string "cubic-bezier(x1, y1, x2, y2)"."""
+
+KeyTime = Union[float, str]
+"""Seconds from the layer start, or "end" / "end-0.5" (relative to the layer end)."""
+
+Keyframe = Union[Tuple[KeyTime, float], Tuple[KeyTime, float, Ease], List[Union[KeyTime, float, str]]]
+"""[time, value] or [time, value, ease]; the ease applies to the segment ending at this key."""
+
+
+# functional syntax because "from" is a Python keyword
+FromTo = TypedDict(
+    "FromTo",
+    {
+        "from": Required[float],
+        "to": Required[float],
+        "ease": Ease,
+        "start": KeyTime,
+        "end": KeyTime,
+        "comment": str,
+    },
+    total=False,
+)
+"""Animate from one value to another over the layer (or between "start" and "end")."""
+
+AnimFn = Callable[[float, Dict[str, float]], float]
+"""f(t, {"frame", "fps", "duration", "progress"}) -> value; sampled per frame by flits.compile()."""
+
+Animated = Union[float, List[Keyframe], FromTo, AnimFn]
+"""A constant, keyframes [[time, value, ease?], ...] or {"from", "to", "ease", "start", "end"}."""
+
+TransitionType = Literal[
+    "fade",
+    "slide-up",
+    "slide-down",
+    "slide-left",
+    "slide-right",
+    "slide-fade",
+    "zoom-in",
+    "zoom-out",
+    "zoom-fade",
+    "zoom-blur",
+    "pop",
+    "wipe-left",
+    "wipe-right",
+    "wipe-up",
+    "wipe-down",
+    "push-left",
+    "push-right",
+    "push-up",
+    "push-down",
+    "rotate-in",
+    "flip-x",
+    "flip-y",
+    "iris",
+    # aliases: rise = slide-fade, zoom = zoom-in, wipe = wipe-right, push = push-right, rotate = rotate-in, flip = flip-x, circle = iris
+    "up",
+    "down",
+    "left",
+    "right",
+    "rise",
+    "zoom",
+    "wipe",
+    "push",
+    "rotate",
+    "flip",
+    "circle",
+]
+
+TransitionSpec = TypedDict(
+    "TransitionSpec",
+    {
+        "type": TransitionType,  # default "fade"
+        "duration": float,  # seconds (default 0.5; pop 0.45; iris and push 0.6)
+        "ease": Ease,  # default "out"; pop "back-out"; wipes, push and iris "in-out"
+        "distance": float,  # slide distance in px (default 120; slide-fade 40)
+        "angle": float,  # rotate-in: degrees turned during the transition (default 90)
+        "comment": str,
+    },
+    total=False,
+)
+
+Transition = Union[str, TransitionSpec]
+""""fade", "pop 0.4" (type + seconds) or a TransitionSpec."""
+
+Duck = Union[bool, float]
+"""True (duck to 0.25) or the volume level (0..1) to duck to while other audio plays."""
+
+Padding = Union[float, Tuple[float, float], List[float]]
+
+LayerType = Literal["rect", "image", "video", "text", "counter", "captions", "waveform", "shape", "group"]
+ShapeKind = Literal["rect", "ellipse", "circle", "line", "arrow", "polygon", "star", "path"]
+LineCap = Literal["round", "butt", "square"]
+Fit = Literal["cover", "contain", "fill", "stretch"]
+Align = Literal["left", "center", "right", "start", "middle", "end"]
+Reveal = Literal["words", "lines", "chars", "typewriter", "none"]
+RevealStyle = Literal["rise", "mask", "fade", "blur"]
+MotionBlurSpec = TypedDict("MotionBlurSpec", {"samples": int, "shutter": float}, total=False)
+MotionBlur = Union[bool, MotionBlurSpec]
+"""True (up to 8 samples, 180 degree shutter) or the most samples per moving layer and the shutter (0.5 = 180 degrees)."""
+Wrap = Literal["balance", "greedy"]
+CaptionStyle = Literal[
+    "karaoke", "pop", "bounce", "word", "line", "highlight", "tiktok", "jump", "single", "plain", "subtitle",
+]
+CaptionPreset = Literal[
+    "tiktok", "karaoke-box", "bounce", "minimal", "neon", "highlighter", "subtitle", "word-pop-big",
+]
+HighlightBox = Literal["pill", "marker", "box", "highlighter"]
+TextBgMode = Literal["box", "lines"]
+GradientType = Literal["linear", "radial"]
+
+# ------------------------------------------------------------------ objects
+
+
+class Border(TypedDict, total=False):
+    """Border drawn outside the box."""
+
+    width: Required[float]
+    color: Required[Color]
+    comment: str
+
+
+class Shadow(TypedDict, total=False):
+    """Drop shadow (text: text shadow; other layers: box shadow)."""
+
+    color: Color  # default "rgba(0,0,0,0.5)"
+    blur: float  # default 24
+    x: float  # default 0
+    y: float  # default 12
+    comment: str
+
+
+class StrokeSpec(TypedDict, total=False):
+    """Text outline."""
+
+    width: Required[float]
+    color: Required[Color]
+    comment: str
+
+
+class TextBg(TypedDict, total=False):
+    """Box (or one pill per line) behind text."""
+
+    color: Required[Color]
+    padding: Padding
+    radius: float
+    mode: TextBgMode
+    comment: str
+
+
+class Filter(TypedDict, total=False):
+    """Colour grading for image and video layers."""
+
+    brightness: float  # added, e.g. 0.05
+    contrast: float  # factor, default 1
+    saturation: float  # factor, default 1 (0 = gray)
+    warmth: float  # e.g. 0.3 (negative = cooler)
+    grayscale: bool
+    comment: str
+
+
+Gradient = TypedDict(
+    "Gradient",
+    {
+        "type": GradientType,  # default "linear"
+        "angle": float,  # CSS-style degrees: 180 = top to bottom (default)
+        "stops": List[Tuple[float, Color]],  # [[offset 0..1, colour], ...]
+        "colors": List[Color],  # spread evenly (alternative to stops)
+        "comment": str,
+    },
+    total=False,
+)
+
+
+class AudioTrack(TypedDict, total=False):
+    """An audio file in the soundtrack."""
+
+    src: Required[str]
+    start: float  # scene time where the track starts
+    trim: float  # seconds to skip in the source
+    duration: float
+    volume: Animated
+    fadeIn: float
+    fadeOut: float
+    loop: bool
+    duck: Duck
+    comment: str
+
+
+Layer = TypedDict(
+    "Layer",
+    {
+        "type": Required[LayerType],
+        "id": str,
+        "start": float,  # seconds, relative to the parent group
+        "end": float,
+        "duration": float,
+        "x": Animated,  # anchor position in px (default: centre of the parent)
+        "y": Animated,
+        "width": float,
+        "height": float,
+        "anchor": Tuple[float, float],  # [0.5, 0.5] = centre (default), [0, 0] = top-left
+        "scale": Animated,
+        "scaleX": Animated,
+        "scaleY": Animated,
+        "rotation": Animated,  # degrees
+        "opacity": Animated,
+        "zoom": Animated,  # image/video: Ken Burns zoom inside the box
+        "panX": Animated,  # -1..1
+        "panY": Animated,
+        "in": Transition,
+        "out": Transition,
+        "radius": float,
+        "border": Border,
+        "shadow": Shadow,
+        "filter": Filter,
+        "clip": bool,  # group: hide everything outside the box
+        "motionBlur": bool,  # False: no motion blur for this layer and its children
+        "comment": str,
+        # image / video / captions / waveform
+        "src": str,
+        "fit": Fit,
+        "blur": float,
+        "trim": float,
+        "volume": Animated,
+        "loop": bool,
+        "speed": float,
+        "fadeIn": float,
+        "fadeOut": float,
+        # rect
+        "color": Color,
+        "gradient": Gradient,
+        # text (and counter/captions styling)
+        "text": str,
+        "font": str,
+        "size": float,
+        "weight": float,
+        "align": Align,
+        "maxWidth": float,
+        "lineHeight": float,
+        "letterSpacing": float,
+        "stroke": StrokeSpec,
+        "background": TextBg,
+        "uppercase": bool,
+        "reveal": Reveal,
+        "wrap": Wrap,
+        "revealDuration": float,
+        "revealStyle": RevealStyle,  # rise (default), mask, fade, blur
+        # captions
+        "preset": CaptionPreset,  # named look; layer properties override it
+        "style": CaptionStyle,
+        "highlight": Color,  # active word colour (default yellow)
+        "highlightBg": Color,  # box behind the active word
+        "highlightBox": HighlightBox,  # "pill" (default) or "marker"
+        "maxWords": int,
+        "maxLines": int,  # default 2
+        "colors": List[Color],  # active-word colours, cycled word by word
+        "activeScale": float,  # active word size (default 1.12 for pop, 1 otherwise)
+        "speakerColors": Dict[str, Color],  # word colour per diarization speaker
+        # shape
+        "shape": ShapeKind,  # rect (default), ellipse, circle, line, arrow, polygon, star, path
+        "points": List[Tuple[float, float]],  # [[x, y], ...] in the layer box
+        "d": str,  # shape "path": SVG path data in layer-box units
+        "sides": int,  # polygon corners (6) / star points (5)
+        "innerRadius": float,  # star: inner radius as a fraction of the outer one (0.5)
+        "lineCap": LineCap,
+        "dash": List[float],  # dash pattern in px, e.g. [20, 10]
+        "progress": Animated,  # how much of the outline is drawn, 0..1 (animate to draw on)
+        "headSize": float,  # arrow head length in px (default 4 x the stroke width)
+        # waveform
+        "bars": int,
+        "mirror": bool,
+        "gap": float,
+        "gain": float,
+        # counter
+        "value": Animated,
+        "decimals": int,
+        "prefix": str,
+        "suffix": str,
+        "separator": str,  # "," (default), "." or "none"
+        # group
+        "children": List["Layer"],
+        "sequence": bool,
+        "overlap": float,
+    },
+    total=False,
+)
+"""One layer. Required per type: image/video/captions/waveform need "src", text needs "text", counter needs "value"."""
+
+Scene = TypedDict(
+    "Scene",
+    {
+        "$schema": str,  # ignored by flits
+        "width": Required[int],
+        "height": Required[int],
+        "fps": float,  # default 30
+        "duration": float,  # default: end of the last layer
+        "background": Color,
+        "fonts": Dict[str, str],  # alias -> font name or file
+        "fontFallback": List[str],  # fonts for characters a layer's font lacks (emoji, other scripts)
+        "audio": List[AudioTrack],
+        "loudness": float,  # LUFS, e.g. -14
+        "motionBlur": MotionBlur,
+        "layers": List[Layer],
+        "comment": str,
+    },
+    total=False,
+)
+"""A flits scene: one video described as layers on a canvas."""

flits_video-0.2.0.dist-info/METADATA

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: flits-video
+Version: 0.2.0
+Summary: Python wrapper for the flits video renderer: build scenes as dicts, render them with the flits CLI
+License: MIT
+Project-URL: Homepage, https://github.com/ArjandenHartog/flits
+Keywords: video,rendering,flits,transcription,captions
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Multimedia :: Video
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: typing_extensions>=4.0; python_version < "3.11"
+
+Render flits scenes (JSON video descriptions) from Python. Needs the `flits` CLI on PATH or $FLITS_BIN. See https://github.com/ArjandenHartog/flits

flits_video-0.2.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+flits/__init__.py,sha256=W04-Pyld293jzsy5MOg94nAJb6ihe2X6rFHfPLEupyo,1047
+flits/_cli.py,sha256=T0pFYiOnXf7BVnyqA_DO4zUMMQZ_Mwss0qn2x6TwB2M,8677
+flits/compile.py,sha256=mkVsinAU6Qdd0U2y2v__jO0RkU-uWeyG2uZxkccVBmM,4531
+flits/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+flits/types.py,sha256=mgcsxHdhU3aT8oef2Ef-9iWMyWUXWu6J4taY-2bJ46s,12021
+flits_video-0.2.0.dist-info/METADATA,sha256=fOMW0RxtIsrI_QAfwwI3AJgkxxUBuCnkNJJ55xXn0So,753
+flits_video-0.2.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+flits_video-0.2.0.dist-info/top_level.txt,sha256=-3yg-zvnKSlQNvHzAu70rEiwLdCSq0oGbc5uLFAvrkg,6
+flits_video-0.2.0.dist-info/RECORD,,

flits_video-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

flits_video-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+flits