creative-render-engine 0.7.0__py3-none-any.whl

creative_render_engine/render.py

@@ -0,0 +1,328 @@
+from __future__ import annotations
+
+import importlib.metadata
+import shutil
+import subprocess
+import tempfile
+import uuid
+from collections.abc import Callable
+from contextlib import ExitStack
+from pathlib import Path
+
+from moviepy import VideoFileClip
+from PIL import Image
+
+from .engines.common import (
+    compose_scroll_frame,
+    compose_timeline_frame,
+    open_audio_clip,
+    prepare_scroll_frames,
+    prepare_timeline_frames,
+    resize_image,
+    write_video,
+)
+from .engines.pure_image import compose_graphic_text, compose_pure_image
+from .errors import RenderError
+from .hashing import file_sha256
+from .plans import (
+    EngineVersions,
+    GraphicTextRenderPlan,
+    ImageRenderOutput,
+    PureImageRenderPlan,
+    RenderManifest,
+    RenderPlan,
+    ResolvedAsset,
+    ScrollBackgroundPlan,
+    ScrollRenderPlan,
+    TimelineRenderPlan,
+    VideoRenderOutput,
+)
+from .schemas import FirstFrameMode
+
+LIBRARY_VERSION = "0.6.1"
+
+
+def render_plan(
+    plan: RenderPlan,
+    output_path: str | Path,
+    *,
+    show_progress: bool = False,
+) -> RenderManifest:
+    destination = Path(output_path).expanduser().resolve()
+    if isinstance(plan, PureImageRenderPlan):
+        return _render_pure_image(plan, destination)
+    if isinstance(plan, GraphicTextRenderPlan):
+        return _render_graphic_text(plan, destination)
+    if destination.suffix.lower() != ".mp4":
+        raise RenderError(
+            "output path must use the .mp4 extension",
+            code="invalid_output_extension",
+            field_path="output_path",
+        )
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    with tempfile.TemporaryDirectory(
+        prefix="creative-render-engine-"
+    ) as workspace_value:
+        workspace = Path(workspace_value)
+        with ExitStack() as stack:
+            if isinstance(plan, ScrollRenderPlan):
+                prepared = prepare_scroll_frames(plan, workspace, stack)
+                first_frame = _scroll_first_frame(plan, prepared)
+
+                def frame_function(timestamp: float):
+                    if first_frame is not None and timestamp < 1 / plan.body.output.fps:
+                        return first_frame.copy()
+                    return compose_scroll_frame(plan, prepared, timestamp)
+
+                backgrounds = [
+                    layer.asset
+                    for layer in plan.body.layers
+                    if isinstance(layer, ScrollBackgroundPlan)
+                ]
+                background_audio_source = next(
+                    (asset for asset in backgrounds if asset.media_type == "video"),
+                    _empty_background_asset(),
+                )
+                audio_clip = open_audio_clip(
+                    plan.body.audio,
+                    background_audio_source,
+                    plan.body.duration_s,
+                    stack,
+                )
+                assets = _scroll_assets(plan)
+                duration = plan.body.duration_s
+                output_spec = plan.body.output
+            elif isinstance(plan, TimelineRenderPlan):
+                background, block_images = prepare_timeline_frames(plan, stack)
+
+                def frame_function(timestamp: float):
+                    return compose_timeline_frame(
+                        plan,
+                        background,
+                        block_images,
+                        timestamp,
+                    )
+
+                audio_clip = open_audio_clip(
+                    plan.body.audio,
+                    plan.body.background,
+                    plan.body.duration_s,
+                    stack,
+                )
+                assets = _timeline_assets(plan)
+                duration = plan.body.duration_s
+                output_spec = plan.body.output
+            else:
+                raise RenderError("unsupported render plan", code="invalid_render_plan")
+            write_video(
+                destination,
+                frame_function,
+                duration,
+                output_spec.fps,
+                output_spec,
+                audio_clip,
+                show_progress=show_progress,
+            )
+    return _build_manifest(plan.plan_hash, destination, assets)
+
+
+def _render_pure_image(plan: PureImageRenderPlan, destination: Path) -> RenderManifest:
+    return _render_png(
+        plan_hash=plan.plan_hash,
+        destination=destination,
+        compose=lambda: compose_pure_image(plan).convert("RGB"),
+        assets=(plan.body.image,),
+        failure_code="pure_image_render_failed",
+    )
+
+
+def _render_graphic_text(
+    plan: GraphicTextRenderPlan,
+    destination: Path,
+) -> RenderManifest:
+    return _render_png(
+        plan_hash=plan.plan_hash,
+        destination=destination,
+        compose=lambda: compose_graphic_text(plan),
+        assets=(plan.body.image, plan.body.text.style.font.font),
+        failure_code="graphic_text_render_failed",
+    )
+
+
+def _render_png(
+    *,
+    plan_hash: str,
+    destination: Path,
+    compose: Callable[[], Image.Image],
+    assets: tuple[ResolvedAsset, ...],
+    failure_code: str,
+) -> RenderManifest:
+    if destination.suffix.lower() != ".png":
+        raise RenderError(
+            "image output path must use the .png extension",
+            code="invalid_output_extension",
+            field_path="output_path",
+        )
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    temporary = destination.with_name(f".{destination.name}.{uuid.uuid4().hex}.tmp")
+    try:
+        compose().save(temporary, format="PNG")
+        temporary.replace(destination)
+    except RenderError:
+        temporary.unlink(missing_ok=True)
+        raise
+    except Exception as exc:
+        temporary.unlink(missing_ok=True)
+        raise RenderError(
+            f"failed to render image: {destination}",
+            code=failure_code,
+            field_path="output_path",
+        ) from exc
+    try:
+        with Image.open(destination) as rendered:
+            rendered.load()
+            width, height = rendered.size
+            if rendered.format != "PNG":
+                raise ValueError("rendered image is not PNG")
+    except Exception as exc:
+        raise RenderError(
+            f"generated image cannot be inspected: {destination}",
+            code="output_inspection_failed",
+        ) from exc
+    return RenderManifest(
+        plan_hash=plan_hash,
+        output=ImageRenderOutput(
+            path=destination,
+            sha256=file_sha256(destination),
+            size_bytes=destination.stat().st_size,
+            width=width,
+            height=height,
+        ),
+        assets=assets,
+        engine_versions=_engine_versions(),
+    )
+
+
+def _engine_versions() -> EngineVersions:
+    return EngineVersions(
+        creative_render_engine=LIBRARY_VERSION,
+        text_block_renderer=_version("text-block-renderer"),
+        moviepy=_version("moviepy"),
+        pillow=_version("pillow"),
+        ffmpeg=_ffmpeg_version(),
+    )
+
+
+def _scroll_first_frame(plan: ScrollRenderPlan, prepared):
+    mode = plan.body.first_frame.mode
+    if mode == FirstFrameMode.COMPOSED:
+        return None
+    if mode == FirstFrameMode.HIDDEN_TEXT:
+        return compose_scroll_frame(plan, prepared, 0.0, hide_text=True)
+    asset = plan.body.first_frame.asset
+    if asset is None:
+        raise RenderError(
+            "first-frame asset is missing", code="missing_first_frame_asset"
+        )
+    from PIL import Image
+
+    try:
+        with Image.open(asset.path) as image:
+            return resize_image(
+                image.copy(),
+                (plan.body.canvas.width, plan.body.canvas.height),
+                "cover",
+            ).convert("RGB")
+    except Exception as exc:
+        raise RenderError(
+            f"failed to load first-frame asset: {asset.path}",
+            code="first_frame_decode_failed",
+        ) from exc
+
+
+def _build_manifest(
+    plan_hash: str,
+    output_path: Path,
+    assets: tuple[ResolvedAsset, ...],
+) -> RenderManifest:
+    try:
+        with VideoFileClip(str(output_path), audio=False) as clip:
+            output = VideoRenderOutput(
+                path=output_path,
+                sha256=file_sha256(output_path),
+                size_bytes=output_path.stat().st_size,
+                width=int(clip.w),
+                height=int(clip.h),
+                duration_s=float(clip.duration),
+                fps=float(clip.fps),
+            )
+    except Exception as exc:
+        raise RenderError(
+            f"generated video cannot be inspected: {output_path}",
+            code="output_inspection_failed",
+        ) from exc
+    return RenderManifest(
+        plan_hash=plan_hash,
+        output=output,
+        assets=assets,
+        engine_versions=_engine_versions(),
+    )
+
+
+def _scroll_assets(plan: ScrollRenderPlan) -> tuple[ResolvedAsset, ...]:
+    assets: dict[str, ResolvedAsset] = {}
+    for layer in plan.body.layers:
+        if isinstance(layer, ScrollBackgroundPlan):
+            assets[layer.asset.id] = layer.asset
+        elif hasattr(layer, "style"):
+            font = layer.style.font.font
+            assets[font.id] = font
+    if plan.body.audio.asset is not None:
+        assets[plan.body.audio.asset.id] = plan.body.audio.asset
+    if plan.body.first_frame.asset is not None:
+        assets[plan.body.first_frame.asset.id] = plan.body.first_frame.asset
+    return tuple(assets[key] for key in sorted(assets))
+
+
+def _timeline_assets(plan: TimelineRenderPlan) -> tuple[ResolvedAsset, ...]:
+    assets = {
+        plan.body.background.id: plan.body.background,
+        plan.body.style.font.font.id: plan.body.style.font.font,
+    }
+    if plan.body.audio.asset is not None:
+        assets[plan.body.audio.asset.id] = plan.body.audio.asset
+    return tuple(assets[key] for key in sorted(assets))
+
+
+def _empty_background_asset() -> ResolvedAsset:
+    return ResolvedAsset(
+        id="no-background-audio",
+        path=Path("."),
+        media_type="image",
+        sha256="0" * 64,
+    )
+
+
+def _version(name: str) -> str:
+    try:
+        return importlib.metadata.version(name)
+    except importlib.metadata.PackageNotFoundError:
+        return "unknown"
+
+
+def _ffmpeg_version() -> str | None:
+    executable = shutil.which("ffmpeg")
+    if executable is None:
+        return None
+    try:
+        completed = subprocess.run(
+            [executable, "-version"],
+            check=True,
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+    except (OSError, subprocess.SubprocessError):
+        return None
+    first_line = completed.stdout.splitlines()[0] if completed.stdout else ""
+    return first_line or None