inkflow 0.1.0.dev0__py3-none-any.whl

inkflow/__init__.py

@@ -0,0 +1,31 @@
+from inkflow.manifest import (
+    Animation,
+    Bounce,
+    Crossfade,
+    Cut,
+    Deck,
+    FadeIn,
+    FadeOut,
+    MarkdownSlide,
+    Media,
+    Morph,
+    Slide,
+    TextBox,
+    Transition,
+)
+
+__all__ = [
+    "Animation",
+    "Bounce",
+    "Crossfade",
+    "Cut",
+    "Deck",
+    "FadeIn",
+    "FadeOut",
+    "MarkdownSlide",
+    "Media",
+    "Morph",
+    "Slide",
+    "TextBox",
+    "Transition",
+]

inkflow/cli.py

@@ -0,0 +1,266 @@
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import subprocess
+import sys
+from pathlib import Path
+from typing import cast
+
+import click
+
+from inkflow import ns
+from inkflow.export import build_pdf, build_static_html
+from inkflow.layout import (
+    inject_layout_layers,
+    is_layout_current,
+    resolve_chain,
+    resolve_parent_path,
+)
+from inkflow.manifest import MarkdownSlide
+from inkflow.pipeline import clean_inkscape_svg, resolve_slide_src
+from inkflow.server import load_deck
+from inkflow.server import serve as _serve
+
+
+@click.group()
+def main() -> None:
+    """Terminal-native SVG presentation tool."""
+
+
+@main.command()
+@click.argument("deck", default="deck.py")
+@click.option("--port", default=7777, show_default=True, help="HTTP port")
+@click.option("--ws-port", default=7778, show_default=True, help="WebSocket port")
+def serve(deck: str, port: int, ws_port: int) -> None:
+    """Start the presentation server."""
+    deck_path = Path(deck).resolve()
+    if not deck_path.exists():
+        raise click.ClickException(f"deck not found: {deck_path}")
+    with contextlib.suppress(KeyboardInterrupt):
+        asyncio.run(_serve(deck_path, port, ws_port))
+
+
+@main.command()
+@click.argument("files", nargs=-1, required=True, type=click.Path(path_type=Path))
+@click.option(
+    "--stdout",
+    "to_stdout",
+    is_flag=True,
+    help="Write to stdout instead of modifying files in place",
+)
+def clean(files: tuple[Path, ...], to_stdout: bool) -> None:
+    """Strip Inkscape editor metadata from SVG files."""
+    errors = False
+    for p in files:
+        if not p.exists():
+            click.echo(f"[inkflow] clean: not found: {p}", err=True)
+            errors = True
+            continue
+        try:
+            cleaned = clean_inkscape_svg(p)
+            if to_stdout:
+                sys.stdout.write(cleaned)
+            else:
+                p.write_text(cleaned, encoding="utf-8")
+                click.echo(f"[inkflow] cleaned {p}")
+        except Exception as exc:
+            click.echo(f"[inkflow] clean: error processing {p}: {exc}", err=True)
+            errors = True
+    if errors:
+        sys.exit(1)
+
+
+@main.command("setup-git")
+def setup_git() -> None:
+    """Configure git hooks and SVG diff driver (run once after cloning)."""
+    steps = [
+        (
+            ["git", "config", "core.hooksPath", ".githooks"],
+            "pre-commit hook → .githooks/pre-commit",
+        ),
+        (
+            [
+                "git",
+                "config",
+                "diff.inkscape-svg.textconv",
+                "uv run inkflow clean --stdout",
+            ],
+            "SVG diff driver → strips Inkscape metadata before diffs",
+        ),
+    ]
+    for cmd, label in steps:
+        try:
+            _ = subprocess.run(cmd, check=True, capture_output=True)
+            click.echo(f"[inkflow] {label}")
+        except subprocess.CalledProcessError as exc:
+            stderr = cast(bytes | None, exc.stderr)
+            msg = stderr.decode().strip() if isinstance(stderr, bytes) else str(exc)
+            raise click.ClickException(f"setup-git failed: {msg}") from exc
+    hook = Path(".githooks/pre-commit")
+    if hook.exists():
+        hook.chmod(hook.stat().st_mode | 0o111)
+    click.echo("[inkflow] done — git is configured for this repository")
+
+
+@main.command("inject-layout")
+@click.argument("deck", default="deck.py", type=click.Path(path_type=Path))
+@click.option(
+    "--check",
+    is_flag=True,
+    help="Report stale files without rewriting them. Exits 1 if any are stale.",
+)
+def inject_layout_cmd(deck: Path, check: bool) -> None:
+    """Refresh ancestor layout layers in all slide SVGs for Inkscape preview."""
+    deck_path = Path(deck).resolve()
+    if not deck_path.exists():
+        raise click.ClickException(f"deck not found: {deck_path}")
+
+    deck_obj = load_deck(deck_path)
+    project_dir = deck_path.parent
+    stale_found = False
+
+    for slide in deck_obj.slides:
+        if isinstance(slide, MarkdownSlide):
+            continue  # MarkdownSlide has no per-slide SVG to inject into
+        svg_path = resolve_slide_src(slide.src, project_dir)
+        chain = resolve_chain(svg_path, project_dir, deck_obj.theme)
+        if not chain:
+            continue
+
+        if check:
+            if is_layout_current(svg_path, chain):
+                click.echo(f"[ok]     {slide.src}")
+            else:
+                click.echo(f"[stale]  {slide.src}")
+                stale_found = True
+        else:
+            changed = inject_layout_layers(svg_path, chain)
+            if changed:
+                click.echo(f"[injected]    {slide.src}")
+            else:
+                click.echo(f"[up to date]  {slide.src}")
+
+    if check and stale_found:
+        sys.exit(1)
+
+
+@main.command("add")
+@click.argument("parent")
+@click.argument("output", type=click.Path(path_type=Path))
+@click.option(
+    "--deck",
+    "deck_path",
+    default="deck.py",
+    type=click.Path(path_type=Path),
+    help="Path to deck.py (default: deck.py in cwd)",
+)
+def add_slide(parent: str, output: Path, deck_path: Path) -> None:
+    """Create a new slide SVG wired to a layout parent.
+
+    PARENT is a layout name or inkflow:parent string:
+    bare name (three-level search), 'local:foo', 'theme:foo', 'builtin:foo',
+    or a relative path. OUTPUT is the path for the new SVG file.
+    """
+    from lxml import etree as _etree
+
+    resolved_deck = Path(deck_path).resolve()
+    if not resolved_deck.exists():
+        raise click.ClickException(f"deck not found: {resolved_deck}")
+
+    deck_obj = load_deck(resolved_deck)
+    project_dir = resolved_deck.parent
+    output_path = Path(output).resolve()
+
+    if output_path.exists():
+        raise click.ClickException(f"file already exists: {output_path}")
+
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+
+    # Resolve parent to get viewBox from the parent SVG if available.
+    try:
+        parent_abs = resolve_parent_path(
+            parent, output_path, project_dir, deck_obj.theme
+        )
+    except ValueError as exc:
+        raise click.ClickException(str(exc)) from exc
+
+    view_box = "0 0 1920 1080"
+    width = "1920"
+    height = "1080"
+    if parent_abs.exists():
+        anc_root = _etree.parse(parent_abs).getroot()
+        if anc_root.get("viewBox"):
+            view_box = anc_root.get("viewBox", view_box)
+            width = anc_root.get("width", width)
+            height = anc_root.get("height", height)
+
+    svg_content = (
+        f'<svg xmlns="{ns.SVG}"\n'
+        f'     xmlns:inkflow="{ns.INKFLOW}"\n'
+        f'     inkflow:parent="{parent}"\n'
+        f'     viewBox="{view_box}" width="{width}" height="{height}">\n'
+        f"</svg>\n"
+    )
+    output_path.write_text(svg_content, encoding="utf-8")
+
+    chain = resolve_chain(output_path, project_dir, deck_obj.theme)
+    if chain:
+        inject_layout_layers(output_path, chain)
+
+    output_rel = output_path.relative_to(project_dir)
+    click.echo(f"[inkflow] created {output_rel}")
+    click.echo("[inkflow] add to deck.py:")
+    click.echo(f'    Slide("{output_rel}"),')
+
+
+@main.command("build")
+@click.argument("deck", default="deck.py")
+@click.option(
+    "--output",
+    "-o",
+    default=None,
+    help="Output directory (default: build/ next to deck.py)",
+)
+def build_cmd(deck: str, output: str | None) -> None:
+    """Export a self-contained presentation directory for offline use."""
+    deck_path = Path(deck).resolve()
+    if not deck_path.exists():
+        raise click.ClickException(f"deck not found: {deck_path}")
+    out_dir = Path(output).resolve() if output else deck_path.parent / "build"
+    build_static_html(deck_path, out_dir)
+    click.echo(f"[inkflow] built {out_dir / 'index.html'}")
+
+
+@main.command("export")
+@click.argument("deck", default="deck.py")
+@click.option(
+    "--output",
+    "-o",
+    default=None,
+    help="Output PDF path (default: <deck-stem>.pdf next to deck.py)",
+)
+@click.option(
+    "--chromium",
+    default=None,
+    help="Path to chromium/chrome binary (auto-detected if not set)",
+)
+@click.option(
+    "--no-sandbox",
+    "no_sandbox",
+    is_flag=True,
+    help="Pass --no-sandbox to Chromium (needed when running as root or in Docker).",
+)
+def export_cmd(
+    deck: str, output: str | None, chromium: str | None, no_sandbox: bool
+) -> None:
+    """Export a PDF via headless Chromium (one page per slide)."""
+    deck_path = Path(deck).resolve()
+    if not deck_path.exists():
+        raise click.ClickException(f"deck not found: {deck_path}")
+    out = Path(output).resolve() if output else deck_path.with_suffix(".pdf")
+    try:
+        build_pdf(deck_path, out, chromium, no_sandbox)
+    except RuntimeError as exc:
+        raise click.ClickException(str(exc)) from exc
+    click.echo(f"[inkflow] exported {out}")

inkflow/content.py

@@ -0,0 +1,227 @@
+from __future__ import annotations
+
+import base64
+import mimetypes
+from dataclasses import dataclass
+from pathlib import Path
+
+from lxml import etree
+
+from inkflow import ns
+from inkflow.manifest import Content, TextBox
+
+_MIME_MAP = {
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+    ".svg": "image/svg+xml",
+}
+
+_VIDEO_SUFFIXES = {".mp4", ".webm", ".ogg", ".mov"}
+
+_ALIGN_MAP: dict[str, tuple[int, int]] = {
+    "center": (50, 50),
+    "top": (50, 0),
+    "bottom": (50, 100),
+    "left": (0, 50),
+    "right": (100, 50),
+    "top-left": (0, 0),
+    "top-right": (100, 0),
+    "bottom-left": (0, 100),
+    "bottom-right": (100, 100),
+}
+
+
+@dataclass
+class _ZoneRect:
+    x: str
+    y: str
+    width: str
+    height: str
+
+
+def substitute_zone_numbers(svg_str: str, slide_number: int, total: int) -> str:
+    root = etree.fromstring(svg_str.encode())
+    for el in root.iter(f"{{{ns.SVG}}}text"):
+        eid = el.get("id", "")
+        if eid == "zone-slide-number":
+            el.text = str(slide_number)
+        elif eid == "zone-slide-total":
+            el.text = str(total)
+    return etree.tostring(root, encoding="unicode")
+
+
+def _rect_geometry(el: etree._Element) -> _ZoneRect:  # pyright: ignore[reportPrivateUsage]
+    x = el.get("x", "0")
+    y = el.get("y", "0")
+    w = el.get("width")
+    h = el.get("height")
+    if w is None or h is None:
+        raise ValueError(f"Zone rect missing width/height: {el.get('id')}")
+    return _ZoneRect(x=x, y=y, width=w, height=h)
+
+
+def _swap_zone(
+    old_el: etree._Element,  # pyright: ignore[reportPrivateUsage]
+    new_el: etree._Element,  # pyright: ignore[reportPrivateUsage]
+    rect: _ZoneRect,
+    zone_id: str,
+) -> None:
+    """Set geometry + id on new_el and swap it in place of old_el in the tree."""
+    new_el.set("id", zone_id)
+    new_el.set("x", rect.x)
+    new_el.set("y", rect.y)
+    new_el.set("width", rect.width)
+    new_el.set("height", rect.height)
+    parent = old_el.getparent()
+    if parent is None:
+        return
+    idx = list(parent).index(old_el)
+    parent.remove(old_el)
+    parent.insert(idx, new_el)
+
+
+def _replace_with_foreignobject(
+    el: etree._Element,  # pyright: ignore[reportPrivateUsage]
+    html: str,
+    zone_id: str,
+    font_size: int,
+) -> None:
+    rect = _rect_geometry(el)
+
+    fo = etree.Element(f"{{{ns.SVG}}}foreignObject")
+    fo.set("overflow", "visible")
+    fo.set(
+        "font-size", str(font_size)
+    )  # SVG user units; cascades into HTML content via em
+
+    # Use XHTML as default namespace so lxml serialises <div>, <p>, <ul>
+    # without a prefix — required for the browser's HTML parser to recognise
+    # them as real HTML elements inside foreignObject.
+    div = etree.Element(
+        f"{{{ns.XHTML}}}div",
+        {"class": "inkflow-content"},
+        nsmap={None: ns.XHTML},  # pyright: ignore[reportArgumentType]
+    )
+    try:
+        fragment = etree.fromstring(f"<div xmlns='{ns.XHTML}'>{html}</div>")
+        div.text = fragment.text
+        for child in fragment:
+            div.append(child)
+    except etree.XMLSyntaxError:
+        div.text = html
+    fo.append(div)
+
+    _swap_zone(el, fo, rect, zone_id)
+
+
+def _fmt_pos(base: int, offset_pct: float) -> str:
+    if offset_pct == 0.0:
+        return f"{base}%"
+    sign = "+" if offset_pct >= 0 else "-"
+    return f"calc({base}% {sign} {abs(offset_pct):.6g}%)"
+
+
+def _replace_with_media(
+    el: etree._Element,  # pyright: ignore[reportPrivateUsage]
+    src: str,
+    zone_id: str,
+    fit: str,
+    align: str,
+    x: float,
+    y: float,
+    project_dir: Path,
+) -> None:
+    rect = _rect_geometry(el)
+
+    base_x, base_y = _ALIGN_MAP.get(align, (50, 50))
+    x_pct = x / float(rect.width) * 100
+    y_pct = y / float(rect.height) * 100
+    style = (
+        f"width:100%;height:100%;"
+        f"object-fit:{fit};"
+        f"object-position:{_fmt_pos(base_x, x_pct)} {_fmt_pos(base_y, y_pct)};"
+        f"display:block;"
+    )
+
+    fo = etree.Element(f"{{{ns.SVG}}}foreignObject")
+    fo.set("overflow", "visible")
+
+    suffix = Path(src).suffix.lower()
+    if suffix in _VIDEO_SUFFIXES:
+        media_el = etree.Element(
+            f"{{{ns.XHTML}}}video",
+            {"src": src, "controls": ""},
+            nsmap={None: ns.XHTML},  # pyright: ignore[reportArgumentType]
+        )
+    else:
+        img_path = project_dir / src
+        mime = (
+            _MIME_MAP.get(suffix)
+            or mimetypes.guess_type(str(img_path))[0]
+            or "image/png"
+        )
+        b64 = base64.b64encode(img_path.read_bytes()).decode()
+        media_el = etree.Element(
+            f"{{{ns.XHTML}}}img",
+            {"src": f"data:{mime};base64,{b64}"},
+            nsmap={None: ns.XHTML},  # pyright: ignore[reportArgumentType]
+        )
+
+    media_el.set("style", style)
+    fo.append(media_el)
+    _swap_zone(el, fo, rect, zone_id)
+
+
+def substitute_content(
+    svg_str: str,
+    content: list[Content],
+    project_dir: Path,
+    font_size: int = 36,
+) -> str:
+    root = etree.fromstring(svg_str.encode())
+
+    for item in content:
+        zone_id = item.element.lstrip("#")
+        el = root.find(f'.//*[@id="{zone_id}"]')
+        if el is None:
+            print(f"[inkflow] warning: zone #{zone_id} not found in SVG")
+            continue
+
+        if isinstance(item, TextBox):
+            _replace_with_foreignobject(el, item.text or "", zone_id, font_size)
+        else:
+            _replace_with_media(
+                el, item.src, zone_id, item.fit, item.align, item.x, item.y, project_dir
+            )
+
+    return etree.tostring(root, encoding="unicode")
+
+
+def remove_unreferenced_zones(svg_str: str) -> str:
+    root = etree.fromstring(svg_str.encode())
+    to_remove = [
+        el
+        for el in root.iter(f"{{{ns.SVG}}}rect")
+        if (el.get("id") or "").startswith("zone-") and not el.get("class")
+    ]
+    for el in to_remove:
+        parent = el.getparent()
+        if parent is not None:
+            parent.remove(el)
+    return etree.tostring(root, encoding="unicode")
+
+
+def inject_style(svg_str: str, css: str) -> str:
+    if not css:
+        return svg_str
+    root = etree.fromstring(svg_str.encode())
+    defs = root.find(f"{{{ns.SVG}}}defs")
+    if defs is None:
+        defs = etree.Element(f"{{{ns.SVG}}}defs")
+        root.insert(0, defs)
+    style = etree.SubElement(defs, f"{{{ns.SVG}}}style")
+    style.text = css
+    return etree.tostring(root, encoding="unicode")

inkflow/export.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+import importlib.resources
+import shutil
+import subprocess
+import tempfile
+from pathlib import Path
+
+from inkflow.manifest import Deck, MarkdownSlide, Media, Slide
+from inkflow.pipeline import process_deck, resolve_transitions
+from inkflow.server import State, build_html, load_deck, load_styles
+
+_VIDEO_SUFFIXES = {".mp4", ".webm", ".ogg", ".mov"}
+
+
+# ── build ─────────────────────────────────────────────────────────────────────
+
+
+def build_static_html(deck_path: Path, out_dir: Path) -> None:
+    deck = load_deck(deck_path)
+    project_dir = deck_path.parent
+    slides = process_deck(deck, project_dir)
+    transitions = resolve_transitions(deck)
+    styles_css = load_styles(deck, project_dir)
+
+    _copy_videos(_collect_video_paths(deck), project_dir, out_dir)
+
+    state: State = {
+        "slides": slides,
+        "transitions": transitions,
+        "styles_css": styles_css,
+        "dark_mode": deck.dark_mode,
+        "ws_clients": set(),
+        "error": None,
+    }
+    out_dir.mkdir(parents=True, exist_ok=True)
+    (out_dir / "index.html").write_bytes(build_html(state, ws_port=None))
+
+
+def _collect_video_paths(deck: Deck) -> list[str]:
+    paths: list[str] = []
+    for slide in deck.slides:
+        items = slide.content if isinstance(slide, Slide) else []
+        for item in items:
+            if (
+                isinstance(item, Media)
+                and Path(item.src).suffix.lower() in _VIDEO_SUFFIXES
+            ):
+                paths.append(item.src)
+        if isinstance(slide, MarkdownSlide):
+            for val in slide._extra.values():  # pyright: ignore[reportPrivateUsage]
+                src = val.src if isinstance(val, Media) else val
+                if Path(src).suffix.lower() in _VIDEO_SUFFIXES:
+                    paths.append(src)
+    return paths
+
+
+def _copy_videos(paths: list[str], project_dir: Path, out_dir: Path) -> None:
+    for rel in paths:
+        src = project_dir / rel
+        dst = out_dir / rel
+        if src.exists():
+            dst.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy2(src, dst)
+
+
+# ── export (PDF) ──────────────────────────────────────────────────────────────
+
+
+def build_pdf(
+    deck_path: Path,
+    output: Path,
+    chromium: str | None = None,
+    no_sandbox: bool = False,
+) -> None:
+    exe = chromium or _find_chromium()
+    if exe is None:
+        raise RuntimeError(
+            "Chromium not found. Install chromium or google-chrome,"
+            + " or pass --chromium PATH."
+        )
+
+    deck = load_deck(deck_path)
+    project_dir = deck_path.parent
+    slides = process_deck(deck, project_dir)
+    styles_css = load_styles(deck, project_dir)
+
+    pkg = importlib.resources.files("inkflow")
+    template = pkg.joinpath("pdf.html").read_text(encoding="utf-8")
+    data_theme = "" if deck.dark_mode else "light"
+    slides_html = "\n".join(f'<div class="slide">{s}</div>' for s in slides)
+    html = (
+        template.replace("__STYLES__", styles_css)
+        .replace("__DATA_THEME__", data_theme)
+        .replace("__SLIDES__", slides_html)
+    )
+
+    with tempfile.TemporaryDirectory() as tmp:
+        html_path = Path(tmp) / "slides.html"
+        html_path.write_text(html, encoding="utf-8")
+        cmd = [
+            exe,
+            "--headless",
+            "--disable-gpu",
+            "--print-to-pdf-no-header",
+            f"--print-to-pdf={output.resolve()}",
+            html_path.as_uri(),
+        ]
+        if no_sandbox:
+            cmd.insert(1, "--no-sandbox")
+        subprocess.run(cmd, check=True)
+
+
+def _find_chromium() -> str | None:
+    for name in (
+        "chromium",
+        "chromium-browser",
+        "google-chrome",
+        "google-chrome-stable",
+    ):
+        if found := shutil.which(name):
+            return found
+    return None