inkflow 0.1.0.dev0__py3-none-any.whl

inkflow/layout.py

@@ -0,0 +1,279 @@
+from __future__ import annotations
+
+import hashlib
+import importlib.resources
+from copy import deepcopy
+from pathlib import Path
+from typing import cast
+
+from lxml import etree
+
+from inkflow import ns
+from inkflow.ns import (
+    INKFLOW_LAYOUT_HASH,
+    INKFLOW_LAYOUT_SRC,
+    INKFLOW_PARENT,
+)
+
+# ── Built-in theme ───────────────────────────────────────────────────────────
+
+
+def _builtin_theme_dir() -> Path:
+    return Path(str(importlib.resources.files("inkflow").joinpath("theme")))
+
+
+def resolve_theme_dir(theme: str, project_root: Path) -> Path:
+    p = Path(theme)
+    if p.is_absolute():
+        return p
+    if theme.startswith(("./", "../")):
+        return (project_root / p).resolve()
+    raise ValueError(
+        f"Named theme '{theme}' is not yet supported. Use a path like './my-theme'."
+    )
+
+
+# ── Parent attribute ──────────────────────────────────────────────────────────
+
+
+def _read_parent_attr(svg_path: Path) -> str | None:
+    tree = etree.parse(svg_path)
+    return tree.getroot().get(INKFLOW_PARENT)
+
+
+# ── Path resolution ───────────────────────────────────────────────────────────
+
+
+def resolve_parent_path(
+    parent_str: str,
+    svg_path: Path,
+    project_root: Path,
+    theme: str | None,
+) -> Path:
+    """Resolve an inkflow:parent string to an absolute Path.
+
+    Prefix syntaxes (bypass the search):
+      local:foo      →  {project_root}/layouts/foo.svg
+      theme:foo      →  {theme_dir}/layouts/foo.svg
+      builtin:foo    →  {builtin_theme_dir}/layouts/foo.svg
+      ./foo, ../foo  →  relative to svg_path's directory
+      /absolute      →  literal filesystem path
+
+    Bare single-part name (no prefix, no separator):
+      Three-level search: project layouts/ → theme layouts/ → built-in layouts/
+    Multi-part relative path (has /, no prefix):
+      Relative to svg_path's directory (backward-compatible with inkflow:parent).
+    """
+
+    def _with_svg(p: Path) -> Path:
+        return p if p.suffix else p.with_suffix(".svg")
+
+    if parent_str.startswith("local:"):
+        name = parent_str[len("local:") :]
+        resolved = _with_svg(project_root / "layouts" / name)
+        if not resolved.exists():
+            raise ValueError(f"local:{name} not found at {resolved}")
+        return resolved
+
+    if parent_str.startswith("theme:"):
+        name = parent_str[len("theme:") :]
+        if theme is None:
+            raise ValueError(f"theme:{name} requires Deck(theme=...) to be set")
+        theme_dir = resolve_theme_dir(theme, project_root)
+        resolved = _with_svg(theme_dir / "layouts" / name)
+        if not resolved.exists():
+            raise ValueError(f"theme:{name} not found at {resolved}")
+        return resolved
+
+    if parent_str.startswith("builtin:"):
+        name = parent_str[len("builtin:") :]
+        resolved = _with_svg(_builtin_theme_dir() / "layouts" / name)
+        if not resolved.exists():
+            raise ValueError(
+                f"builtin:{name} not found — no built-in layout named '{name}'"
+            )
+        return resolved
+
+    if parent_str.startswith(("./", "../")):
+        return _with_svg((svg_path.parent / parent_str).resolve())
+
+    if parent_str.startswith("/"):
+        return _with_svg(Path(parent_str))
+
+    # Multi-part relative path (has /) — relative to svg_path's parent
+    if "/" in parent_str:
+        return _with_svg((svg_path.parent / parent_str).resolve())
+
+    # Bare single-part name — three-level search
+    name = parent_str
+    candidates: list[Path] = [_with_svg(project_root / "layouts" / name)]
+    if theme is not None:
+        candidates.append(
+            _with_svg(resolve_theme_dir(theme, project_root) / "layouts" / name)
+        )
+    candidates.append(_with_svg(_builtin_theme_dir() / "layouts" / name))
+
+    for candidate in candidates:
+        if candidate.exists():
+            return candidate
+
+    searched = "\n".join(f"  {c}" for c in candidates)
+    raise ValueError(f"Layout '{name}' not found. Searched:\n{searched}")
+
+
+# ── Chain resolution ──────────────────────────────────────────────────────────
+
+
+def resolve_chain(
+    svg_path: Path,
+    project_root: Path,
+    theme: str | None,
+) -> list[Path]:
+    """Return the ancestor chain for svg_path, root-first, excluding svg_path itself.
+
+    Returns an empty list if the file has no inkflow:parent.
+    Raises ValueError on circular chains.
+    """
+    chain: list[Path] = []
+    current = svg_path.resolve()
+    visited: set[Path] = {current}
+
+    while True:
+        parent_str = _read_parent_attr(current)
+        if parent_str is None:
+            break
+        parent_path = resolve_parent_path(parent_str, current, project_root, theme)
+        if parent_path in visited:
+            raise ValueError(f"Circular inkflow:parent chain detected at {parent_path}")
+        visited.add(parent_path)
+        chain.insert(0, parent_path)
+        current = parent_path
+
+    return chain
+
+
+# ── Layout layer stripping ────────────────────────────────────────────────────
+
+
+def strip_layout_layers(root: etree._Element) -> None:  # pyright: ignore[reportPrivateUsage]
+    """Remove direct-child <g> elements injected by inject_layout_layers."""
+    to_remove = [el for el in root if el.get(INKFLOW_LAYOUT_SRC) is not None]
+    for el in to_remove:
+        root.remove(el)
+
+
+# ── inject_layout_layers ──────────────────────────────────────────────────────
+
+
+def _layer_hashes(chain: list[Path]) -> dict[str, str]:
+    hashes: dict[str, str] = {}
+    for p in chain:
+        digest = hashlib.sha1(p.read_bytes()).hexdigest()[:8]
+        hashes[str(p.resolve())] = digest
+    return hashes
+
+
+def _chain_refs(svg_path: Path, chain: list[Path]) -> list[str]:
+    """Return the inkflow:parent ref string for each ancestor in the chain.
+
+    The ref for chain[i] is the inkflow:parent value on its child — chain[i+1]
+    for all but the last entry, svg_path for the last.
+    """
+    children = [*chain[1:], svg_path]
+    return [_read_parent_attr(child) or "" for child in children]
+
+
+def is_layout_current(svg_path: Path, chain: list[Path]) -> bool:
+    """Return True if svg_path already has up-to-date inject-layout layers."""
+    root = etree.parse(svg_path).getroot()
+    existing = [el for el in root if el.get(INKFLOW_LAYOUT_SRC) is not None]
+    if len(existing) != len(chain):
+        return False
+    new_hashes = _layer_hashes(chain)
+    refs = _chain_refs(svg_path, chain)
+    for el, p, ref in zip(existing, chain, refs, strict=True):
+        if el.get(INKFLOW_LAYOUT_SRC) != ref:
+            return False
+        if el.get(INKFLOW_LAYOUT_HASH) != new_hashes[str(p.resolve())]:
+            return False
+    return True
+
+
+def _build_layer_group(
+    ancestor_path: Path, ref: str, hashes: dict[str, str]
+) -> etree._Element:  # pyright: ignore[reportPrivateUsage]
+    anc_root = etree.parse(ancestor_path).getroot()
+    strip_layout_layers(anc_root)
+
+    g = etree.Element(
+        f"{{{ns.SVG}}}g",
+        {
+            f"{{{ns.INKSCAPE}}}groupmode": "layer",
+            f"{{{ns.INKSCAPE}}}label": f"__inkflow:layout:{ancestor_path.stem}__",
+            f"{{{ns.SODIPODI}}}insensitive": "true",
+            INKFLOW_LAYOUT_SRC: ref,
+            INKFLOW_LAYOUT_HASH: hashes[str(ancestor_path.resolve())],
+        },
+    )
+
+    defs_children: list[etree._Element] = []  # pyright: ignore[reportPrivateUsage]
+    for defs_el in anc_root.findall(f"{{{ns.SVG}}}defs"):
+        defs_children.extend(list(defs_el))
+    if defs_children:
+        g_defs = etree.SubElement(g, f"{{{ns.SVG}}}defs")
+        for def_el in defs_children:
+            g_defs.append(deepcopy(def_el))
+
+    for child in anc_root:
+        if child.tag != f"{{{ns.SVG}}}defs":
+            g.append(deepcopy(child))
+
+    return g
+
+
+def _with_namespaces(
+    root: etree._Element,  # pyright: ignore[reportPrivateUsage]
+    additions: dict[str, str],
+) -> etree._Element:  # pyright: ignore[reportPrivateUsage]
+    """Return root with extra namespace prefixes declared.
+
+    lxml nsmap is immutable after construction, so adding prefixes requires
+    rebuilding the root element with an extended nsmap.
+    """
+    missing = {k: v for k, v in additions.items() if k not in root.nsmap}
+    if not missing:
+        return root
+    new_root = etree.Element(
+        root.tag,
+        attrib=cast("dict[str, str]", dict(root.attrib)),
+        nsmap=cast("dict[str, str]", {**root.nsmap, **missing}),
+    )
+    for child in root:
+        new_root.append(child)
+    return new_root
+
+
+def inject_layout_layers(svg_path: Path, chain: list[Path]) -> bool:
+    """Inject ancestor SVGs as locked Inkscape layers into svg_path in place.
+
+    Returns True if the file was modified, False if already up to date.
+    """
+    if is_layout_current(svg_path, chain):
+        return False
+
+    root = etree.parse(svg_path).getroot()
+    hashes = _layer_hashes(chain)
+
+    for el in [el for el in root if el.get(INKFLOW_LAYOUT_SRC) is not None]:
+        root.remove(el)
+
+    refs = _chain_refs(svg_path, chain)
+    for i, (ancestor_path, ref) in enumerate(zip(chain, refs, strict=True)):
+        root.insert(i, _build_layer_group(ancestor_path, ref, hashes))
+
+    out = _with_namespaces(root, {"inkscape": ns.INKSCAPE, "sodipodi": ns.SODIPODI})
+    svg_path.write_text(
+        etree.tostring(out, encoding="unicode", xml_declaration=False),
+        encoding="utf-8",
+    )
+    return True

inkflow/manifest.py

@@ -0,0 +1,145 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Protocol, runtime_checkable
+
+# ── Animation ────────────────────────────────────────────────────────────────
+
+
+@dataclass
+class FadeIn:
+    element: str
+    step: int = 1
+
+
+@dataclass
+class FadeOut:
+    element: str
+    step: int = 1
+
+
+@dataclass
+class Bounce:
+    element: str
+    step: int = 1
+
+
+@runtime_checkable
+class Animation(Protocol):
+    element: str
+    step: int
+
+
+# ── Transition ────────────────────────────────────────────────────────────────
+
+
+@dataclass
+class Cut:
+    duration: float = 0.0
+
+
+@dataclass
+class Crossfade:
+    duration: float = 0.4
+
+
+@dataclass
+class Morph:
+    duration: float = 0.5
+
+
+@runtime_checkable
+class Transition(Protocol):
+    duration: float
+
+
+# ── Content types ─────────────────────────────────────────────────────────────
+
+
+@dataclass
+class TextBox:
+    element: str
+    text: str | None = None
+    steps: bool = False
+
+
+@dataclass
+class Media:
+    src: str
+    fit: str = "contain"
+    align: str = "center"
+    x: float = 0.0
+    y: float = 0.0
+    element: str = field(default="", kw_only=True)
+
+
+Content = TextBox | Media
+
+
+# ── Slide / Deck ──────────────────────────────────────────────────────────────
+
+
+@dataclass
+class Slide:
+    src: str
+    animations: list[Animation] = field(default_factory=list)
+    transition: Transition | None = None
+    content: list[Content] = field(default_factory=list)
+    style: str = ""
+
+    @property
+    def step_count(self) -> int:
+        return max((a.step for a in self.animations), default=0)
+
+
+class MarkdownSlide:
+    template: str
+    content: str | None
+    steps: bool
+    animations: list[Animation]
+    transition: Transition | None
+    style: str
+    _extra: dict[str, str | Media]
+
+    def __init__(
+        self,
+        template: str,
+        *,
+        content: str | None = None,
+        steps: bool = False,
+        animations: list[Animation] | None = None,
+        transition: Transition | None = None,
+        style: str = "",
+        **kwargs: str | Media,
+    ) -> None:
+        self.template = template
+        self.content = content
+        self.steps = steps
+        self.animations = animations or []
+        self.transition = transition
+        self.style = style
+        self._extra = kwargs
+
+
+class Deck:
+    slides: list[Slide | MarkdownSlide]
+    transition: Transition | None
+    theme: str | None
+    dark_mode: bool
+    style: str
+    font_size: int
+
+    def __init__(
+        self,
+        transition: Transition | None = None,
+        theme: str | None = None,
+        dark_mode: bool = True,
+        style: str = "",
+        font_size: int = 36,
+    ) -> None:
+        self.slides = []
+        self.transition = transition
+        self.theme = theme
+        self.dark_mode = dark_mode
+        self.style = style
+        self.font_size = font_size

inkflow/markdown.py

@@ -0,0 +1,158 @@
+from __future__ import annotations
+
+import re
+from dataclasses import replace
+from pathlib import Path
+from typing import cast
+
+from markdown_it import MarkdownIt
+
+from inkflow.manifest import Content, Media, TextBox
+
+_ZONE_PATTERN = re.compile(r"^::((?!step\b)[\w-]+)::\s*$", re.MULTILINE)
+_STEP_PATTERN = re.compile(r"^::step::\s*$", re.MULTILINE)
+_STEP = "\x00step\x00"
+
+_md = MarkdownIt()
+
+
+def markdown_to_html(md_str: str) -> str:
+    return cast(str, _md.render(md_str))
+
+
+def _split_steps(text: str) -> list[str]:
+    parts = _STEP_PATTERN.split(text)
+    result: list[str] = []
+    for i, part in enumerate(parts):
+        if i > 0:
+            result.append(_STEP)
+        result.append(part)
+    return result
+
+
+def _auto_extract(text: str) -> dict[str, list[str]]:
+    zones: dict[str, list[str]] = {}
+    lines = text.splitlines(keepends=True)
+    i = 0
+    n = len(lines)
+
+    # Extract leading # H1
+    while i < n and not lines[i].strip():
+        i += 1
+    if i < n and lines[i].startswith("# "):
+        zones["title"] = [lines[i].rstrip()]
+        i += 1
+
+        # Check for ## H2 immediately following (only blank lines between)
+        j = i
+        while j < n and not lines[j].strip():
+            j += 1
+        if j < n and lines[j].startswith("## "):
+            zones["subtitle"] = [lines[j].rstrip()]
+            i = j + 1
+
+    rest = "".join(lines[i:]).strip()
+    if rest:
+        zones["content"] = _split_steps(rest)
+
+    return zones
+
+
+def parse_markdown_zones(md_path: Path) -> dict[str, list[str]]:
+    text = md_path.read_text(encoding="utf-8")
+
+    markers = list(_ZONE_PATTERN.finditer(text))
+    if not markers:
+        return _auto_extract(text)
+
+    zones: dict[str, list[str]] = {}
+
+    # Content before the first marker:
+    # auto-extract title/subtitle, remainder → "content"
+    before = text[: markers[0].start()].strip()
+    if before:
+        zones.update(_auto_extract(before))
+
+    for idx, m in enumerate(markers):
+        zone_name = m.group(1)
+        start = m.end()
+        end = markers[idx + 1].start() if idx + 1 < len(markers) else len(text)
+        section = text[start:end].strip()
+        if section:
+            zones[zone_name] = _split_steps(section)
+
+    return zones
+
+
+def chunks_to_html(chunks: list[str], base_step: int) -> tuple[str, int]:
+    parts: list[str] = []
+    step = base_step
+    chunk_index = 0
+
+    for item in chunks:
+        if item == _STEP:
+            step += 1
+            continue
+        if chunk_index == 0:
+            parts.append(markdown_to_html(item))
+        else:
+            html = markdown_to_html(item)
+            parts.append(f'<div class="anim-fade-in" data-step="{step}">{html}</div>')
+        chunk_index += 1
+
+    return "".join(parts), step
+
+
+def steps_wrap_list_items(html: str, base_step: int) -> tuple[str, int]:
+    from lxml import etree
+
+    # Wrap in a root element to parse as fragment
+    wrapped = f"<div>{html}</div>"
+    root = etree.fromstring(wrapped.encode())
+
+    step = base_step
+    for ul_or_ol in root.findall("ul") + root.findall("ol"):
+        for li in ul_or_ol:
+            if li.tag != "li":
+                continue
+            step += 1
+            wrapper = etree.Element("div")
+            wrapper.set("class", "anim-fade-in")
+            wrapper.set("data-step", str(step))
+            # Move li into wrapper
+            idx = list(ul_or_ol).index(li)
+            ul_or_ol.remove(li)
+            wrapper.append(li)
+            ul_or_ol.insert(idx, wrapper)
+
+    inner = etree.tostring(root, encoding="unicode")
+    # Strip outer <div> wrapper
+    inner = inner[len("<div>") : -len("</div>")]
+    return inner, step
+
+
+def build_slide_content(
+    content_path: Path | None,
+    steps: bool,
+    extra: dict[str, str | Media],
+) -> list[Content]:
+    zones: dict[str, list[str]] = {}
+    if content_path is not None:
+        zones = parse_markdown_zones(content_path)
+
+    content: list[Content] = []
+    base_step = 0
+
+    for zone_name, chunks in zones.items():
+        html, base_step = chunks_to_html(chunks, base_step)
+        if steps:
+            html, base_step = steps_wrap_list_items(html, base_step)
+        content.append(TextBox(f"#zone-{zone_name}", text=html))
+
+    for key, val in extra.items():
+        if isinstance(val, Media):
+            content.append(replace(val, element=f"#zone-{key}"))
+        else:
+            content.append(Media(val, element=f"#zone-{key}"))
+
+    return content

inkflow/ns.py

@@ -0,0 +1,9 @@
+SVG = "http://www.w3.org/2000/svg"
+XHTML = "http://www.w3.org/1999/xhtml"
+INKFLOW = "urn:inkflow"
+INKSCAPE = "http://www.inkscape.org/namespaces/inkscape"
+SODIPODI = "http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+
+INKFLOW_PARENT = f"{{{INKFLOW}}}parent"
+INKFLOW_LAYOUT_SRC = f"{{{INKFLOW}}}layout-src"
+INKFLOW_LAYOUT_HASH = f"{{{INKFLOW}}}layout-hash"

inkflow/pdf.html

@@ -0,0 +1,19 @@
+<!DOCTYPE html>
+<html lang="en" data-theme="__DATA_THEME__">
+<head>
+  <meta charset="UTF-8">
+  <style>
+    @page { size: 1920px 1080px; margin: 0; }
+    * { box-sizing: border-box; }
+    body { margin: 0; padding: 0; }
+    .slide { width: 1920px; height: 1080px; overflow: hidden; break-after: page; }
+    .slide svg { width: 100%; height: 100%; display: block; }
+    [data-step] { opacity: 1 !important; transform: none !important; }
+    .anim-fade-out[data-step] { opacity: 0 !important; }
+  </style>
+  <style>__STYLES__</style>
+</head>
+<body>
+__SLIDES__
+</body>
+</html>