simplex-web 0.2.0__py3-none-any.whl

simplex/deck/config.py

@@ -0,0 +1,207 @@
+"""DeckConfig -- pydantic model loaded from each deck's deck.toml.
+
+Two scene-list spellings are accepted:
+
+- ``entrypoints = ["slides.intro:Title", ...]`` -- preferred, points at scene
+  classes inside the deck's ``slides/`` package.
+- ``scenes = ["Title", ...]`` -- legacy, bare class names in a top-level
+  ``slides.py``. Kept for backwards compatibility with the single-file layout.
+
+``section_slug`` is populated by the registry, not the author.
+
+Three nested override types tune per-deck or per-main-slide behaviour:
+
+- ``SlideOverride`` -- per-main-slide tweaks (thumbnail path/index, notes
+  anchor, order). Keyed by the main slide's ``name=`` in ``deck.slides``.
+- ``WebOverride`` -- per-deck portal + RevealJS palette overrides
+  (``deck.web``). Every field is optional; ``resolved_web_palette()``
+  merges with the active theme's defaults field-by-field.
+"""
+
+import re
+import tomllib
+from datetime import date
+from pathlib import Path
+from typing import Self
+
+from pydantic import BaseModel, ConfigDict, field_validator, model_validator
+
+from simplex.theme.presets import get as get_theme
+from simplex.theme.tokens import WebPalette
+
+_SLUG = re.compile(r"^[a-z0-9]+(?:-[a-z0-9]+)*$")
+_ENTRYPOINT = re.compile(r"^[A-Za-z_][\w.]*:[A-Za-z_]\w*$")
+
+
+class SlideOverride(BaseModel):
+    """Per-main-slide override. Keyed by the ``name=`` passed to next_slide."""
+
+    model_config = ConfigDict(frozen=True)
+    thumbnail: Path | None = None
+    thumbnail_section_index: int = -2
+    notes_anchor: str | None = None
+    order_override: float | None = None
+
+
+class WebOverride(BaseModel):
+    """Per-deck portal + RevealJS overrides. Every field is optional.
+
+    Resolution: ``deck.web`` field if non-None > ``theme.web_palette`` field >
+    ``WebPalette()`` default. RevealJS-specific fields (``transition``,
+    ``controls``, ...) are passed straight to the converter.
+    """
+
+    model_config = ConfigDict(frozen=True)
+    accent: str | None = None
+    background: str | None = None
+    surface: str | None = None
+    text_primary: str | None = None
+    text_muted: str | None = None
+    link: str | None = None
+    code_background: str | None = None
+    font_family_sans: str | None = None
+    font_family_mono: str | None = None
+    font_size_base: str | None = None
+
+    # RevealJS knobs (forwarded to manim_slides.convert.RevealJS kwargs).
+    # Default ``"none"``: the next video replaces the previous one with no
+    # animation. This keeps both desktop and mobile playback direction-free.
+    transition: str = "none"
+    controls: bool = True
+    progress: bool = True
+    hash_navigation: bool = True
+
+    # Slide-presentation chrome. These used to be drawn into each frame
+    # by ``make_chrome(..., page=)``; they now live in the RevealJS host
+    # so toggling them is free (no re-render).
+    show_slide_number: bool = False
+    show_clock: bool = False
+
+    # Homepage/section carousel preview. ``carousel_gif`` points to a
+    # user-authored GIF relative to the deck directory. When omitted,
+    # ``carousel_gif_slides`` can select 1-based main-slide indexes to
+    # synthesize a small progressive preview from rendered video segments.
+    carousel_gif: Path | None = None
+    carousel_gif_slides: tuple[int, ...] = ()
+
+    @field_validator("carousel_gif_slides")
+    @classmethod
+    def _carousel_gif_slides_positive(cls, value: tuple[int, ...]) -> tuple[int, ...]:
+        if any(i < 1 for i in value):
+            raise ValueError("carousel_gif_slides uses 1-based slide indexes")
+        return value
+
+    # Escape hatches.
+    custom_css_path: Path | None = None
+    template: Path | None = None
+
+
+class DeckConfig(BaseModel):
+    model_config = ConfigDict(frozen=True)
+    slug: str
+    title: str
+    summary: str = ""
+    tags: tuple[str, ...] = ()
+    theme: str = "dastimator_dark"
+    scenes: tuple[str, ...] = ()
+    entrypoints: tuple[str, ...] = ()
+    quality: str = "high_quality"
+    voiceover: bool = False
+    category: str | None = None
+    duration_minutes: int | None = None
+    created_at: date | None = None
+    order: int = 1000
+    path: Path
+    section_slug: str = "featured"
+
+    # v0.2 additions.
+    caching: bool = True
+    self_test: bool = False
+    render_quality_dev: str = "low_quality"
+    render_quality_release: str = "high_quality"
+    slides: dict[str, SlideOverride] = {}
+    slide_order: tuple[str, ...] = ()
+    web: WebOverride = WebOverride()
+
+    @field_validator("slug")
+    @classmethod
+    def _slug_format(cls, value: str) -> str:
+        if not _SLUG.match(value):
+            raise ValueError(f"slug must be kebab-case (a-z0-9 with single hyphens), got {value!r}")
+        return value
+
+    @field_validator("entrypoints")
+    @classmethod
+    def _entrypoint_format(cls, value: tuple[str, ...]) -> tuple[str, ...]:
+        for ep in value:
+            if not _ENTRYPOINT.match(ep):
+                raise ValueError(f"entrypoint must be 'module[.sub]:ClassName', got {ep!r}")
+        return value
+
+    @model_validator(mode="after")
+    def _at_least_one_scene_source(self) -> Self:
+        return self
+
+    @property
+    def scene_specs(self) -> tuple[str, ...]:
+        """Return entrypoints if present, else legacy ``slides.py``-relative scenes."""
+        if self.entrypoints:
+            return self.entrypoints
+        return tuple(f"slides:{name}" for name in self.scenes)
+
+    @property
+    def scene_class_names(self) -> tuple[str, ...]:
+        """Bare class names extracted from ``scene_specs``."""
+        return tuple(spec.rsplit(":", 1)[-1] for spec in self.scene_specs)
+
+    def resolve_entrypoints(self) -> tuple[tuple[Path, tuple[str, ...]], ...]:
+        """Group entrypoints by their source file, in declaration order."""
+        groups: dict[Path, list[str]] = {}
+        for spec in self.scene_specs:
+            module, _, class_name = spec.partition(":")
+            file_path = self._module_to_file(module)
+            groups.setdefault(file_path, []).append(class_name)
+        return tuple((file_path, tuple(names)) for file_path, names in groups.items())
+
+    def resolved_web_palette(self) -> WebPalette:
+        """Merge per-deck ``web`` overrides over the active theme's palette.
+
+        Returns a fully-resolved ``WebPalette`` (every field set). Used by
+        the web builder + RevealJS template injection.
+        """
+        theme = get_theme(self.theme)
+        base = theme.web_palette
+        web = self.web
+        return WebPalette(
+            accent=web.accent or base.accent,
+            background=web.background or base.background,
+            surface=web.surface or base.surface,
+            text_primary=web.text_primary or base.text_primary,
+            text_muted=web.text_muted or base.text_muted,
+            link=web.link or base.link,
+            code_background=web.code_background or base.code_background,
+            font_family_sans=web.font_family_sans or base.font_family_sans,
+            font_family_mono=web.font_family_mono or base.font_family_mono,
+            font_size_base=web.font_size_base or base.font_size_base,
+        )
+
+    def _module_to_file(self, module: str) -> Path:
+        """Map ``slides.foo.bar`` to the deck-relative ``.py`` file."""
+        parts = module.split(".")
+        module_path = self.path.joinpath(*parts)
+        as_file = module_path.with_suffix(".py")
+        if as_file.exists():
+            return as_file
+        as_pkg = module_path / "__init__.py"
+        if as_pkg.exists():
+            return as_pkg
+        raise FileNotFoundError(
+            f"deck {self.slug!r}: entrypoint module {module!r} resolves to neither "
+            f"{as_file} nor {as_pkg}"
+        )
+
+    @classmethod
+    def load(cls, deck_dir: Path, *, section_slug: str = "featured") -> Self:
+        toml_path = deck_dir / "deck.toml"
+        data = tomllib.loads(toml_path.read_text(encoding="utf-8"))
+        return cls(**data, path=deck_dir, section_slug=section_slug)

simplex/deck/registry.py

@@ -0,0 +1,110 @@
+"""Discover sections + decks on disk.
+
+Layout:
+
+    decks/
+      <featured-slug>/deck.toml         # featured section
+      <section>/_section.toml           # carousel metadata (optional)
+      <section>/<slug>/deck.toml         # sectioned decks
+
+Recursion is exactly one level deep. Decks placed deeper than that raise.
+The walker preserves legacy single-file `slides.py` decks as well as the
+new `slides/` package layout.
+"""
+
+from pathlib import Path
+
+from pydantic import BaseModel, ConfigDict
+
+from simplex.deck.config import DeckConfig
+from simplex.deck.section import FEATURED_SLUG, SectionConfig
+
+_SKIP_PREFIXES = ("_", ".")
+
+
+def _is_skipped(name: str) -> bool:
+    return name.startswith(_SKIP_PREFIXES)
+
+
+def _is_deck_dir(p: Path) -> bool:
+    return p.is_dir() and not _is_skipped(p.name) and (p / "deck.toml").exists()
+
+
+class Section(BaseModel):
+    model_config = ConfigDict(frozen=True, arbitrary_types_allowed=True)
+    config: SectionConfig
+    decks: tuple[DeckConfig, ...]
+
+
+class SectionedRegistry(BaseModel):
+    model_config = ConfigDict(frozen=True, arbitrary_types_allowed=True)
+    sections: tuple[Section, ...]
+
+    @property
+    def all_decks(self) -> tuple[DeckConfig, ...]:
+        return tuple(d for s in self.sections for d in s.decks)
+
+    def find_deck(self, slug: str) -> DeckConfig | None:
+        for deck in self.all_decks:
+            if deck.slug == slug:
+                return deck
+        return None
+
+
+def _section_sort_key(
+    section: Section,
+    default_order: tuple[str, ...],
+) -> tuple[int, int, str]:
+    cfg = section.config
+    if cfg.slug in default_order:
+        return (0, default_order.index(cfg.slug), cfg.title)
+    return (1, cfg.order, cfg.title)
+
+
+def discover(
+    decks_dir: Path,
+    *,
+    default_section_order: tuple[str, ...] = (),
+) -> SectionedRegistry:
+    """Return every section + deck discoverable under `decks_dir`."""
+    if not decks_dir.exists():
+        return SectionedRegistry(sections=())
+
+    featured_decks: list[DeckConfig] = []
+    sections: list[Section] = []
+
+    for entry in sorted(decks_dir.iterdir()):
+        if _is_skipped(entry.name):
+            continue
+        if _is_deck_dir(entry):
+            featured_decks.append(DeckConfig.load(entry, section_slug=FEATURED_SLUG))
+            continue
+        if not entry.is_dir():
+            continue
+        cfg = SectionConfig.load(entry)
+        decks: list[DeckConfig] = []
+        for child in sorted(entry.iterdir()):
+            if _is_skipped(child.name):
+                continue
+            if _is_deck_dir(child):
+                decks.append(DeckConfig.load(child, section_slug=cfg.slug))
+                continue
+            if child.is_dir() and any(child.rglob("deck.toml")):
+                raise ValueError(
+                    f"decks/ supports exactly one level of sections; "
+                    f"found a deck.toml below {child}"
+                )
+        if decks:
+            decks.sort(key=lambda d: (d.order, d.slug))
+            sections.append(Section(config=cfg, decks=tuple(decks)))
+
+    if featured_decks:
+        featured_decks.sort(key=lambda d: (d.order, d.slug))
+        featured = Section(
+            config=SectionConfig.featured(),
+            decks=tuple(featured_decks),
+        )
+        sections.insert(0, featured)
+
+    sections.sort(key=lambda s: _section_sort_key(s, default_section_order))
+    return SectionedRegistry(sections=tuple(sections))

simplex/deck/scaffold.py

@@ -0,0 +1,86 @@
+"""Materialise a new deck folder from the bundled ``_template/``.
+
+The template ships with the ``simplex`` package (``simplex/deck/_template/``)
+so ``simplex new`` works from any directory, not just inside the simplex
+checkout. Callers can still pass an explicit ``template_dir`` to override.
+
+`simplex new <section>/<slug>` creates `decks/<section>/<slug>/`.
+`simplex new <slug>` creates `decks/<slug>/` (featured section).
+"""
+
+import shutil
+from datetime import UTC, datetime
+from pathlib import Path
+
+from simplex.deck.section import FEATURED_SLUG
+
+_TOKENS = ("__SLUG__", "__SECTION__", "__TITLE__", "__CREATED_AT__")
+_BUNDLED_TEMPLATE = Path(__file__).resolve().parent / "_template"
+
+
+def _humanise(slug: str) -> str:
+    return slug.replace("-", " ").replace("_", " ").title()
+
+
+def split_target(target: str) -> tuple[str, str]:
+    """Split a `simplex new` argument into (section, slug)."""
+    target = target.strip().strip("/")
+    if "/" in target:
+        section, _, slug = target.partition("/")
+        if not section or not slug or "/" in slug:
+            raise ValueError(f"target must be 'section/slug' or 'slug', got {target!r}")
+        return section, slug
+    return FEATURED_SLUG, target
+
+
+def _substitute_tokens(path: Path, slug: str, section: str) -> None:
+    text = path.read_text(encoding="utf-8")
+    replaced = (
+        text.replace("__SLUG__", slug)
+        .replace("__SECTION__", section)
+        .replace("__TITLE__", _humanise(slug))
+        .replace("__CREATED_AT__", datetime.now(UTC).date().isoformat())
+    )
+    if replaced != text:
+        path.write_text(replaced, encoding="utf-8")
+
+
+def scaffold(
+    target: str,
+    decks_dir: Path,
+    *,
+    template_dir: Path | None = None,
+) -> Path:
+    """Copy the deck template into ``decks/[section/]<slug>/``, substituting tokens.
+
+    The template defaults to the one bundled with the ``simplex`` package so
+    that ``simplex new`` works in any project. Tests (and power users wanting
+    a custom starter) pass ``template_dir`` to point at a different source.
+    """
+    template = template_dir if template_dir is not None else _BUNDLED_TEMPLATE
+    if not template.exists():
+        raise FileNotFoundError(f"_template not found at {template}")
+
+    section, slug = split_target(target)
+
+    if section == FEATURED_SLUG:
+        dest = decks_dir / slug
+    else:
+        section_dir = decks_dir / section
+        section_dir.mkdir(parents=True, exist_ok=True)
+        dest = section_dir / slug
+
+    if dest.exists():
+        raise FileExistsError(f"deck already exists at {dest}")
+
+    shutil.copytree(template, dest)
+    for token_file in dest.rglob("*"):
+        if not token_file.is_file():
+            continue
+        if token_file.suffix.lower() in {".png", ".jpg", ".jpeg", ".pdf", ".mp4"}:
+            continue
+        try:
+            _substitute_tokens(token_file, slug=slug, section=section)
+        except UnicodeDecodeError:
+            continue
+    return dest

simplex/deck/section.py

@@ -0,0 +1,40 @@
+"""SectionConfig -- metadata for one carousel/subject under `decks/<dir>/`."""
+
+import tomllib
+from pathlib import Path
+from typing import Self
+
+from pydantic import BaseModel, ConfigDict
+
+FEATURED_SLUG = "featured"
+FEATURED_TITLE = "Featured"
+_SECTION_TOML = "_section.toml"
+
+
+def _humanise(slug: str) -> str:
+    return slug.replace("-", " ").replace("_", " ").title()
+
+
+class SectionConfig(BaseModel):
+    model_config = ConfigDict(frozen=True)
+    slug: str
+    title: str
+    order: int = 1000
+    blurb: str = ""
+    icon: str | None = None
+
+    @classmethod
+    def load(cls, section_dir: Path) -> Self:
+        """Load `_section.toml` for `section_dir`; fall back to dir-name defaults."""
+        toml_path = section_dir / _SECTION_TOML
+        data: dict[str, object] = {}
+        if toml_path.exists():
+            data = dict(tomllib.loads(toml_path.read_text(encoding="utf-8")))
+        data.setdefault("slug", section_dir.name)
+        data.setdefault("title", _humanise(section_dir.name))
+        return cls(**data)  # type: ignore[arg-type]
+
+    @classmethod
+    def featured(cls) -> Self:
+        """Synthetic section for decks placed directly under `decks/`."""
+        return cls(slug=FEATURED_SLUG, title=FEATURED_TITLE, order=0)

simplex/engine/README.md

@@ -0,0 +1,9 @@
+# engine/
+
+Namespace placeholder for `simplex.engine` in this repo.
+
+The implementation lives in the `manim-simplex` distribution and is merged via PEP 420.
+
+## Don't
+
+- Don't add code here; keep engine helpers in manim-simplex.

simplex/render/README.md

@@ -0,0 +1,46 @@
+# render/
+
+Manim-slides subprocess invocation, native-section reconcile, thumbnail
+extraction, PDF / PowerPoint export, HTML viewer emission.
+
+## Public surface
+
+- `runner.render(deck, output_dir, scenes=(), write_last_frame=False)` --
+  spawns `manim-slides render` with `--save_sections` (and
+  `--disable_caching` when `deck.caching = False`).
+- `pdf.export(deck, output_dir)` -- in-process via
+  `manim_slides.convert.PDF`.
+- `pptx.export(deck, output_dir)` -- in-process via
+  `manim_slides.convert.PowerPoint`.
+- `reconcile.build_manifest(deck, media_dir)` -> `DeckManifest`
+  (a tuple of `MainSlide`, each with its own `subsections`).
+- `thumbnail.generate(deck, manifest, site_deck_dir, cache_dir)` --
+  ffmpeg last-frame extraction (default rule: second-to-last subsection).
+- `html.render_html(deck, manifest, output_dir, static_prefix)` --
+  Jinja-renders `web/templates/revealjs.html.j2` with the main/sub tree.
+
+## Smart compilation
+
+The plugin sets `manim.config.save_sections = True`. Combined with manim's
+per-animation hash cache, re-editing one animation re-encodes only that
+animation; sections of only-cached animations are stitched from disk. No
+separate Simplex render cache -- run `uv run simplex clean --deck <slug>`
+to force a clean re-render.
+
+## Reconcile
+
+`build_manifest` walks each scene's
+`media/videos/<src>/<q>/sections/<Scene>.json` (written by manim when
+`save_sections=True`): every `type.startswith("simplex.main")` (and the
+auto-created first `default.normal`) starts a new `MainSlide`; everything
+else attaches as a `Subsection` of the current main. The parallel
+`media/slides/<Scene>.json` is consumed only by the PDF / PPTX converters.
+
+## Don't
+
+- Don't shell-quote (`shell=True`); always pass arg lists.
+- Don't add a parallel cache stamp -- the manim per-animation cache is
+  already content-addressable.
+- Don't write outside `output_dir`.
+- Don't read manim-slides' `PresentationConfig` JSON for hierarchy info;
+  the section JSON is the source of truth.

simplex/render/__init__.py

@@ -0,0 +1 @@
+"""Render pipeline: manim-slides subprocess + reconcile + html/pdf/pptx export."""

simplex/render/html.py

@@ -0,0 +1,132 @@
+"""Render ``slides.html`` for one deck from the reconciled main/sub manifest.
+
+Why we keep a custom template (instead of ``manim_slides.convert.RevealJS``):
+
+The template at ``web/templates/revealjs.html.j2`` carries a polished
+RevealJS host -- postMessage bridge to the parent ``deck.html``, touch tap
+zones, disabled RevealJS layout (so videos fill the iframe natively),
+custom progress bar styling via CSS variables. The manim-slides default
+template doesn't have any of that. We do still use
+``manim_slides.convert.PDF`` / ``PowerPoint`` for those formats; they have
+no custom layout requirements.
+
+The web palette is injected as a ``<style>:root {…}</style>`` block at the
+top of ``<head>`` (theme defaults + per-deck overrides via
+``DeckConfig.resolved_web_palette()``). A per-deck ``[web] custom_css_path``
+is appended verbatim as a second ``<style>`` block.
+"""
+
+import shutil
+from dataclasses import dataclass
+from pathlib import Path
+
+from jinja2 import Environment, PackageLoader, select_autoescape
+
+from simplex.deck.config import DeckConfig
+from simplex.manifest import DeckManifest, Subsection
+from simplex.theme.web_css import render_web_css
+
+
+@dataclass(frozen=True, slots=True)
+class _SubView:
+    name: str
+    section_type: str
+    video_href: str | None
+
+
+@dataclass(frozen=True, slots=True)
+class _MainView:
+    index: int
+    scene: str
+    name: str
+    subsections: tuple[_SubView, ...]
+
+
+def _env() -> Environment:
+    return Environment(
+        loader=PackageLoader("simplex.web", "templates"),
+        autoescape=select_autoescape(["html", "j2"]),
+        trim_blocks=True,
+        lstrip_blocks=True,
+    )
+
+
+def _copy_segments(manifest: DeckManifest, dest_dir: Path) -> list[_MainView]:
+    """Copy every subsection video into ``dest_dir/segments/`` with stable names."""
+    seg_dir = dest_dir / "segments"
+    out: list[_MainView] = []
+    for main in manifest.main_slides:
+        sub_views: list[_SubView] = []
+        for sub_idx, sub in enumerate(main.subsections):
+            sub_views.append(
+                _SubView(
+                    name=sub.name,
+                    section_type=sub.section_type.value,
+                    video_href=_copy_one(sub, main.index, sub_idx, seg_dir, dest_dir),
+                )
+            )
+        out.append(
+            _MainView(
+                index=main.index,
+                scene=main.scene,
+                name=main.name,
+                subsections=tuple(sub_views),
+            )
+        )
+    return out
+
+
+def _copy_one(
+    sub: Subsection,
+    main_idx: int,
+    sub_idx: int,
+    seg_dir: Path,
+    dest_dir: Path,
+) -> str | None:
+    if sub.video is None or not sub.video.exists():
+        return None
+    seg_dir.mkdir(parents=True, exist_ok=True)
+    target = seg_dir / f"{main_idx:04d}_{sub_idx:02d}.mp4"
+    if not target.exists() or target.stat().st_mtime < sub.video.stat().st_mtime:
+        shutil.copy2(sub.video, target)
+    return target.relative_to(dest_dir).as_posix()
+
+
+def render_html(
+    deck: DeckConfig,
+    manifest: DeckManifest,
+    *,
+    output_dir: Path,
+    static_prefix: str,
+    watch: bool = False,
+) -> Path:
+    """Write ``output_dir/slides.html`` and copy its video segments.
+
+    `watch=True` includes an SSE client snippet that listens to
+    `/_simplex/events` for live reload (used by `simplex serve --watch`).
+    """
+    output_dir.mkdir(parents=True, exist_ok=True)
+    main_views = _copy_segments(manifest, output_dir)
+    palette_css = render_web_css(deck.resolved_web_palette())
+    deck_custom_css = ""
+    if deck.web.custom_css_path is not None:
+        candidate = deck.path / deck.web.custom_css_path
+        if candidate.exists():
+            deck_custom_css = candidate.read_text(encoding="utf-8")
+
+    template = _env().get_template("revealjs.html.j2")
+    html = template.render(
+        deck=deck,
+        main_slides=main_views,
+        main_slide_count=len(main_views),
+        static_prefix=static_prefix.rstrip("/"),
+        palette_css=palette_css,
+        deck_custom_css=deck_custom_css,
+        transition=deck.web.transition,
+        show_slide_number=deck.web.show_slide_number,
+        show_clock=deck.web.show_clock,
+        watch=watch,
+    )
+    out = output_dir / "slides.html"
+    out.write_text(html, encoding="utf-8")
+    return out

simplex/render/pdf.py

@@ -0,0 +1,32 @@
+"""Convert a rendered deck to PDF via ``manim_slides.convert.PDF`` in-process.
+
+The PDF converter takes the per-scene ``PresentationConfig`` objects
+written by manim-slides during render (under ``<output_dir>/slides/*.json``)
+and writes one combined PDF. No subprocess, no shell.
+"""
+
+from pathlib import Path
+
+from simplex.deck.config import DeckConfig
+
+
+def export(deck: DeckConfig, *, output_dir: Path) -> Path:
+    """Write ``<output_dir>/<slug>.pdf`` from manim-slides' rendered scenes."""
+    from manim_slides.convert import PDF
+    from manim_slides.present import get_scenes_presentation_config
+
+    output_dir.mkdir(parents=True, exist_ok=True)
+    media_dir = output_dir.resolve()
+    pdf_path = media_dir / f"{deck.slug}.pdf"
+    scenes = deck.scene_class_names
+    if not scenes:
+        raise ValueError(f"deck {deck.slug!r} has no scenes/entrypoints configured")
+
+    presentation_configs = get_scenes_presentation_config(
+        list(scenes),
+        media_dir / "slides",
+    )
+    PDF(presentation_configs=presentation_configs).convert_to(  # pyright: ignore[reportCallIssue]
+        pdf_path
+    )
+    return pdf_path