pytex-preprocessor 0.1.0__py3-none-any.whl

pytex_protocol/shortcodes.py

@@ -0,0 +1,130 @@
+"""Inline ``{{shortcode}}`` expansion for protocol Markdown.
+
+Shortcodes are the inline counterpart to the block callouts: small widgets
+(``{{time 18:30}}``, ``{{vote ja=12 nein=3 enthaltung=2}}``) and references to
+frontmatter fields (``{{anwesend}}``, ``{{count anwesend}}``, ``{{datum}}``).
+
+Unknown shortcodes are rendered back verbatim (escaped) so a typo is visible
+in the PDF rather than silently dropped.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import TYPE_CHECKING, Final
+
+from pytex.commands.builtin import Textbf
+from pytex.commands.colors import Textcolor
+from pytex.helpers.sanitize import escape_latex
+from pytex.model.concat import Concat
+from pytex.model.raw import Raw
+
+from .entries import Timestamp
+
+if TYPE_CHECKING:
+    from collections.abc import Mapping
+
+    from pytex.interface.tex import TeX
+
+    from .frontmatter import FrontmatterValue
+
+__all__ = ["SHORTCODE_RE", "expand_inline_shortcodes", "expand_shortcode"]
+
+SHORTCODE_RE: Final[re.Pattern[str]] = re.compile(r"\{\{\s*(.*?)\s*\}\}")
+
+# Frontmatter keys that can be referenced inline by their bare name.
+_FIELD_ALIASES: Final[dict[str, tuple[str, ...]]] = {
+    "gremium": ("gremium",),
+    "datum": ("datum", "date"),
+    "beginn": ("beginn", "start"),
+    "ende": ("ende", "end"),
+    "ort": ("ort",),
+    "sitzungsleitung": ("sitzungsleitung",),
+    "protokoll": ("protokoll",),
+    "anwesend": ("anwesend",),
+    "abwesend": ("abwesend",),
+    "entschuldigt": ("entschuldigt",),
+    "gaeste": ("gaeste", "gäste"),
+}
+_LIST_FIELDS: Final[frozenset[str]] = frozenset(
+    {"anwesend", "abwesend", "entschuldigt", "gaeste"}
+)
+
+
+def _as_list(value: FrontmatterValue | None) -> list[str]:
+    if value is None:
+        return []
+    if isinstance(value, list):
+        return value
+    return [v.strip() for v in value.split(",") if v.strip()]
+
+
+def _lookup(
+    meta: Mapping[str, FrontmatterValue], field: str
+) -> FrontmatterValue | None:
+    for key in _FIELD_ALIASES.get(field, (field,)):
+        if key in meta:
+            return meta[key]
+    return None
+
+
+def _verbatim(inner: str) -> TeX:
+    return Raw(escape_latex(f"{{{{{inner}}}}}"))
+
+
+def _vote(args: dict[str, str]) -> TeX:
+    def count(*keys: str) -> int:
+        for key in keys:
+            if key in args:
+                try:
+                    return int(args[key])
+                except ValueError:
+                    return 0
+        return 0
+
+    yes, no, abstain = (
+        count("ja", "yes"),
+        count("nein", "no"),
+        count("enthaltung", "enth", "abstain"),
+    )
+    color = "britishracinggreen" if yes > no else "red" if yes < no else "eggplant"
+    summary = f"Ja {yes} · Nein {no} · Enthaltung {abstain}"
+    return Concat(Textbf("Abstimmung: "), Textcolor(color, summary))
+
+
+def _parse_kwargs(rest: str) -> dict[str, str]:
+    return dict(token.split("=", 1) for token in rest.split() if "=" in token)
+
+
+def expand_shortcode(inner: str, meta: Mapping[str, FrontmatterValue]) -> TeX:
+    """Expand a single ``{{...}}`` body (without braces) to a TeX node."""
+    name, _, rest = inner.strip().partition(" ")
+    name = name.lower()
+    rest = rest.strip()
+
+    if name == "time" and rest:
+        return Timestamp(rest)
+    if name == "vote":
+        return _vote(_parse_kwargs(rest))
+    if name == "count":
+        return Raw(str(len(_as_list(_lookup(meta, rest.lower())))))
+    if name in _FIELD_ALIASES:
+        value = _lookup(meta, name)
+        if name in _LIST_FIELDS:
+            return Raw(escape_latex(", ".join(_as_list(value))))
+        return Raw(escape_latex(value if isinstance(value, str) else ""))
+    return _verbatim(inner)
+
+
+def expand_inline_shortcodes(text: str, meta: Mapping[str, FrontmatterValue]) -> TeX:
+    """Split `text` on ``{{...}}`` markers, escaping prose and expanding codes."""
+    parts: list[TeX] = []
+    pos = 0
+    for match in SHORTCODE_RE.finditer(text):
+        if match.start() > pos:
+            parts.append(Raw(escape_latex(text[pos : match.start()])))
+        parts.append(expand_shortcode(match.group(1), meta))
+        pos = match.end()
+    if pos < len(text):
+        parts.append(Raw(escape_latex(text[pos:])))
+    return Concat(*parts)

pytex_protocol/signatures.py

@@ -0,0 +1,84 @@
+"""Signature lines for protocol sign-off (Sitzungsleitung, Schriftführung, …).
+
+Rendered as side-by-side blocks (signature rule, printed name, role), two per
+row, under an "Unterschriften" heading. Names are pulled from the frontmatter
+when known; otherwise the line is left blank to be signed by hand.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from pytex.helpers.sanitize import escape_latex
+from pytex.model.raw import Raw
+from pytex.registry import Registry
+
+if TYPE_CHECKING:
+    from collections.abc import Mapping
+
+    from pytex.interface.tex import TeX
+
+    from .frontmatter import FrontmatterValue
+
+__all__ = ["SignatureLines", "signature_block_from_meta"]
+
+# Role label (lower-cased) -> frontmatter keys that may hold the signer's name.
+_ROLE_NAME_KEYS: dict[str, tuple[str, ...]] = {
+    "sitzungsleitung": ("sitzungsleitung",),
+    "schriftführung": ("protokoll", "schriftführung", "schriftfuehrung"),
+    "schriftfuehrung": ("protokoll", "schriftfuehrung"),
+    "protokoll": ("protokoll",),
+    "vorstand": ("vorstand",),
+}
+_RULE_WIDTH = "5cm"
+
+
+def _cell(role: str, name: str) -> str:
+    printed = escape_latex(name) if name else "~"
+    return (
+        r"\begin{minipage}[t]{0.46\linewidth}\centering"
+        + rf"\rule{{{_RULE_WIDTH}}}{{0.4pt}}\\[0.4em]"
+        + printed
+        + r"\\{\small "
+        + escape_latex(role)
+        + r"}\end{minipage}"
+    )
+
+
+@Registry.add
+def SignatureLines(*signers: tuple[str, str] | str) -> TeX:
+    """Side-by-side signature blocks (rule, name, role), two per row.
+
+    Each signer is a ``(role, name)`` pair; a bare string is a role with a
+    blank line to be signed by hand.
+    """
+    pairs = [(s, "") if isinstance(s, str) else s for s in signers]
+    if not pairs:
+        return Raw("")
+    rows = [
+        r"\noindent "
+        + r"\hfill".join(_cell(role, name) for role, name in pairs[i : i + 2])
+        for i in range(0, len(pairs), 2)
+    ]
+    block = r"\par\vspace{3.5em}".join(rows)
+    return Raw(r"\par\vspace{2em}\section*{Unterschriften}\par\vspace{3em}" + block)
+
+
+def _name_for(role: str, meta: Mapping[str, FrontmatterValue]) -> str:
+    key = role.lower().strip()
+    for candidate in _ROLE_NAME_KEYS.get(key, (key,)):
+        value = meta.get(candidate)
+        if isinstance(value, str) and value:
+            return value
+    return ""
+
+
+def signature_block_from_meta(meta: Mapping[str, FrontmatterValue]) -> TeX | None:
+    """Build a signature block from an ``unterschriften`` frontmatter list.
+
+    Returns None when the key is absent, so callers can append conditionally.
+    """
+    roles = meta.get("unterschriften")
+    if not isinstance(roles, list) or not roles:
+        return None
+    return SignatureLines(*((str(role), _name_for(str(role), meta)) for role in roles))

pytex_tikz/__init__.py

@@ -0,0 +1,25 @@
+from . import tikz
+from .tikz import (
+    Circle,
+    Coordinate,
+    Draw,
+    Fill,
+    Node,
+    Rectangle,
+    Scope,
+    TikzLibrary,
+    TikzPicture,
+)
+
+__all__ = [
+    "Circle",
+    "Coordinate",
+    "Draw",
+    "Fill",
+    "Node",
+    "Rectangle",
+    "Scope",
+    "TikzLibrary",
+    "TikzPicture",
+    "tikz",
+]

pytex_tikz/tikz.py

@@ -0,0 +1,272 @@
+from dataclasses import dataclass, field
+from typing import Final, override
+
+from pytex.helpers.parenting import attach
+from pytex.interface.package import PackageProtocol
+from pytex.interface.tex import TeX
+from pytex.packages import PGF, TIKZ
+from pytex.registry import Registry
+
+__all__ = [
+    "Circle",
+    "Coordinate",
+    "Draw",
+    "Fill",
+    "Node",
+    "Rectangle",
+    "Scope",
+    "TikzLibrary",
+    "TikzPicture",
+]
+
+type TikzOption = str | tuple[str, str]
+type TikzCoord = str | tuple[float, float] | "Coordinate" | "Node"
+
+
+def _render_options(options: tuple[TikzOption, ...]) -> str:
+    if not options:
+        return ""
+    return (
+        "["
+        + ",".join(o if isinstance(o, str) else f"{o[0]}={o[1]}" for o in options)
+        + "]"
+    )
+
+
+def _render_pos(pos: TikzCoord) -> str:
+    if isinstance(pos, Coordinate):
+        return f"({pos.name})"
+    if isinstance(pos, Node):
+        if pos.name is None:
+            raise ValueError("Node used as position must have a name")
+        return f"({pos.name})"
+    if isinstance(pos, tuple):
+        return f"({pos[0]},{pos[1]})"
+    if pos.startswith("("):
+        return pos
+    return f"({pos})"
+
+
+@Registry.add
+@dataclass(frozen=True)
+class Coordinate(TeX):
+    name: Final[str]
+    at: Final[tuple[float, float] | None] = None
+    options: Final[tuple[TikzOption, ...]] = ()
+
+    @property
+    @override
+    def rendered(self) -> str:
+        opts = _render_options(self.options)
+        if self.at is None:
+            return f"\\coordinate{opts} ({self.name});"
+        return f"\\coordinate{opts} ({self.name}) at ({self.at[0]},{self.at[1]});"
+
+    @property
+    @override
+    def requires(self) -> frozenset[PackageProtocol]:
+        return frozenset({TIKZ})
+
+
+@Registry.add
+@dataclass(frozen=True)
+class Node(TeX):
+    label: Final[TeX | str] = ""
+    name: Final[str | None] = None
+    at: Final[TikzCoord | None] = None
+    options: Final[tuple[TikzOption, ...]] = ()
+    _parent: "TeX | None" = field(default=None, init=False, compare=False, repr=False)
+
+    def __post_init__(self) -> None:
+        attach(self, self.label)
+
+    @property
+    @override
+    def rendered(self) -> str:
+        parts: list[str] = ["\\node"]
+        parts.append(_render_options(self.options))
+        if self.name is not None:
+            parts.append(f" ({self.name})")
+        if self.at is not None:
+            parts.append(f" at {_render_pos(self.at)}")
+        parts.append(f" {{{self.label}}};")
+        return "".join(parts)
+
+    @property
+    @override
+    def children(self) -> tuple[TeX, ...]:
+        return (self.label,) if isinstance(self.label, TeX) else ()
+
+    @property
+    @override
+    def requires(self) -> frozenset[PackageProtocol]:
+        return frozenset({TIKZ})
+
+
+@Registry.add
+@dataclass(frozen=True)
+class Draw(TeX):
+    points: Final[tuple[TikzCoord, ...]]
+    op: Final[str] = "--"
+    options: Final[tuple[TikzOption, ...]] = ()
+    cycle: Final[bool] = False
+
+    @property
+    @override
+    def rendered(self) -> str:
+        opts = _render_options(self.options)
+        path = f" {self.op} ".join(_render_pos(p) for p in self.points)
+        if self.cycle:
+            path = f"{path} {self.op} cycle"
+        return f"\\draw{opts} {path};"
+
+    @property
+    @override
+    def requires(self) -> frozenset[PackageProtocol]:
+        return frozenset({TIKZ})
+
+
+@Registry.add
+@dataclass(frozen=True)
+class Fill(TeX):
+    points: Final[tuple[TikzCoord, ...]]
+    options: Final[tuple[TikzOption, ...]] = ()
+    op: Final[str] = "--"
+
+    @property
+    @override
+    def rendered(self) -> str:
+        opts = _render_options(self.options)
+        path = f" {self.op} ".join(_render_pos(p) for p in self.points)
+        return f"\\fill{opts} {path} -- cycle;"
+
+    @property
+    @override
+    def requires(self) -> frozenset[PackageProtocol]:
+        return frozenset({TIKZ})
+
+
+@Registry.add
+@dataclass(frozen=True)
+class Circle(TeX):
+    center: Final[TikzCoord]
+    radius: Final[float | str]
+    options: Final[tuple[TikzOption, ...]] = ()
+    fill: Final[bool] = False
+
+    @property
+    @override
+    def rendered(self) -> str:
+        opts = _render_options(self.options)
+        cmd = "\\fill" if self.fill else "\\draw"
+        return f"{cmd}{opts} {_render_pos(self.center)} circle ({self.radius});"
+
+    @property
+    @override
+    def requires(self) -> frozenset[PackageProtocol]:
+        return frozenset({TIKZ})
+
+
+@Registry.add
+@dataclass(frozen=True)
+class Rectangle(TeX):
+    a: Final[TikzCoord]
+    b: Final[TikzCoord]
+    options: Final[tuple[TikzOption, ...]] = ()
+    fill: Final[bool] = False
+
+    @property
+    @override
+    def rendered(self) -> str:
+        opts = _render_options(self.options)
+        cmd = "\\fill" if self.fill else "\\draw"
+        return f"{cmd}{opts} {_render_pos(self.a)} rectangle {_render_pos(self.b)};"
+
+    @property
+    @override
+    def requires(self) -> frozenset[PackageProtocol]:
+        return frozenset({TIKZ})
+
+
+@Registry.add
+@dataclass(frozen=True)
+class TikzPicture(TeX):
+    elements: Final[tuple[TeX, ...]]
+    options: Final[tuple[TikzOption, ...]] = ()
+
+    def __init__(
+        self,
+        *elements: TeX,
+        options: tuple[TikzOption, ...] = (),
+    ) -> None:
+        object.__setattr__(self, "elements", elements)
+        object.__setattr__(self, "options", options)
+        object.__setattr__(self, "_parent", None)
+        attach(self, *elements)
+
+    @property
+    @override
+    def rendered(self) -> str:
+        opts = _render_options(self.options)
+        inner = "\n".join(e.rendered for e in self.elements)
+        return f"\\begin{{tikzpicture}}{opts}\n{inner}\n\\end{{tikzpicture}}"
+
+    @property
+    @override
+    def children(self) -> tuple[TeX, ...]:
+        return self.elements
+
+    @property
+    @override
+    def requires(self) -> frozenset[PackageProtocol]:
+        return frozenset({TIKZ, PGF})
+
+
+@Registry.add
+@dataclass(frozen=True)
+class TikzLibrary(TeX):
+    name: Final[str]
+
+    @property
+    @override
+    def rendered(self) -> str:
+        return f"\\usetikzlibrary{{{self.name}}}"
+
+    @property
+    @override
+    def requires(self) -> frozenset[PackageProtocol]:
+        return frozenset({TIKZ})
+
+
+@Registry.add
+@dataclass(frozen=True)
+class Scope(TeX):
+    elements: Final[tuple[TeX, ...]]
+    options: Final[tuple[TikzOption, ...]] = ()
+
+    def __init__(
+        self,
+        *elements: TeX,
+        options: tuple[TikzOption, ...] = (),
+    ) -> None:
+        object.__setattr__(self, "elements", elements)
+        object.__setattr__(self, "options", options)
+        object.__setattr__(self, "_parent", None)
+        attach(self, *elements)
+
+    @property
+    @override
+    def rendered(self) -> str:
+        opts = _render_options(self.options)
+        inner = "\n".join(e.rendered for e in self.elements)
+        return f"\\begin{{scope}}{opts}\n{inner}\n\\end{{scope}}"
+
+    @property
+    @override
+    def children(self) -> tuple[TeX, ...]:
+        return self.elements
+
+    @property
+    @override
+    def requires(self) -> frozenset[PackageProtocol]:
+        return frozenset({TIKZ})