pytex-preprocessor 0.1.0__py3-none-any.whl

pytex_hsrtreport/watermark.py

@@ -0,0 +1,63 @@
+from typing import Final
+
+from pytex.helpers.with_package import with_package
+from pytex.interface.tex import TeX
+from pytex.model.control_sequence import ControlSequence, Parameter
+from pytex.model.package import DefinePackage
+from pytex.model.raw import Raw
+from pytex.packages import ACCSUPP, IFTHEN, PGFFOR, XCOLOR
+from pytex.registry import Registry
+
+__all__ = ["DraftWatermark", "WatermarkCounter", "WatermarkPackages"]
+
+DRAFTWATERMARK: Final = DefinePackage("draftwatermark")
+
+
+def _watermark_text(text: str) -> str:
+    """Build the tiled watermark grid: 100 rows × 16 cols, accessibility-friendly."""
+    safe = text.replace("\\", "\\\\").replace("{", "\\{").replace("}", "\\}")
+    return (
+        r"\setcounter{it}{1}"
+        + r"\whiledo{\theit<100}{"
+        + r"\foreach \col in {0,...,15}{\color{black!5}\BeginAccSupp{ActualText=}"
+        + f"{safe}~~"
+        + r"\EndAccSupp{}}\\"
+        + r"\stepcounter{it}}"
+    )
+
+
+@Registry.add
+@with_package(DRAFTWATERMARK)
+@with_package(IFTHEN)
+@with_package(PGFFOR)
+@with_package(ACCSUPP)
+@with_package(XCOLOR)
+def DraftWatermark(
+    text: str,
+    scale: float = 0.08,
+    angle: float = 45,
+    color: str = "black!12",
+) -> TeX:
+    """Configure draftwatermark with tiled accessibility-safe text grid."""
+    body = (
+        f"scale={scale},angle={angle},"
+        + f"text={{\\begin{{tabular}}{{c}}{_watermark_text(text)}\\end{{tabular}}}},"
+        + f"color={color}"
+    )
+    return ControlSequence("DraftwatermarkOptions", (Parameter(Raw(body)),))
+
+
+@Registry.add
+def WatermarkCounter() -> TeX:
+    """Declares the `it` counter used by DraftWatermark. Emit once in preamble."""
+    return Raw("\\newcounter{it}")
+
+
+@Registry.add
+def WatermarkPackages() -> TeX:
+    """Render `\\usepackage` lines for all packages required by watermark."""
+    return ControlSequence(
+        "RequirePackage",
+        (Parameter("draftwatermark"),),
+        required_packages=frozenset({IFTHEN, PGFFOR, ACCSUPP, XCOLOR, DRAFTWATERMARK}),
+    )

pytex_hsrtreport/wordcount.py

@@ -0,0 +1,33 @@
+from pytex.commands.definitions import Newcommand
+from pytex.interface.tex import TeX
+from pytex.model.concat import Concat
+from pytex.model.raw import Raw
+from pytex.registry import Registry
+
+__all__ = ["WordcountCommands"]
+
+
+@Registry.add
+def WordcountCommands() -> TeX:
+    """Define `\\quickwordcount{<doc>}` + `\\detailtexcount{<doc>}` macros.
+
+    Both shell out to `texcount` and require `-shell-escape` build.
+    """
+    return Concat(
+        Newcommand(
+            r"\quickwordcount",
+            Raw(
+                r"\immediate\write18{texcount -1 -sum -merge -q #1.tex > Build/words.sum }"  # noqa: E501
+                + r"\input{Build/words.sum} words"
+            ),
+            nargs=1,
+        ),
+        Newcommand(
+            r"\detailtexcount",
+            Raw(
+                r"\immediate\write18{texcount -merge -sum -q #1.tex > Build/.wcdetail }"
+                + r"\verbatiminput{Build/.wcdetail}"
+            ),
+            nargs=1,
+        ),
+    )

pytex_koma/__init__.py

@@ -0,0 +1,90 @@
+from . import commands
+from .commands import (
+    Addchap,
+    Addmargin,
+    Addpart,
+    Addsec,
+    Addtokomafont,
+    Appendix,
+    Areaset,
+    Automark,
+    Backmatter,
+    Captionabove,
+    Captionbelow,
+    Cfoot,
+    Chead,
+    Clearpairofpagestyles,
+    Clearscrheadfoot,
+    Dedication,
+    Dictum,
+    Extratitle,
+    Frontmatter,
+    Ifoot,
+    Ihead,
+    KOMAoption,
+    KOMAoptions,
+    Labeling,
+    Lowertitleback,
+    Mainmatter,
+    Marginline,
+    Minisec,
+    Ofoot,
+    Ohead,
+    Pagestyle,
+    Publishers,
+    Recalctypearea,
+    Setkomafont,
+    Subject,
+    Subtitle,
+    Titlehead,
+    Typearea,
+    Uppertitleback,
+    Usekomafont,
+)
+from .document import KOMA_CLASSES, KomaDocument
+
+__all__ = [
+    "KOMA_CLASSES",
+    "Addchap",
+    "Addmargin",
+    "Addpart",
+    "Addsec",
+    "Addtokomafont",
+    "Appendix",
+    "Areaset",
+    "Automark",
+    "Backmatter",
+    "Captionabove",
+    "Captionbelow",
+    "Cfoot",
+    "Chead",
+    "Clearpairofpagestyles",
+    "Clearscrheadfoot",
+    "Dedication",
+    "Dictum",
+    "Extratitle",
+    "Frontmatter",
+    "Ifoot",
+    "Ihead",
+    "KOMAoption",
+    "KOMAoptions",
+    "KomaDocument",
+    "Labeling",
+    "Lowertitleback",
+    "Mainmatter",
+    "Marginline",
+    "Minisec",
+    "Ofoot",
+    "Ohead",
+    "Pagestyle",
+    "Publishers",
+    "Recalctypearea",
+    "Setkomafont",
+    "Subject",
+    "Subtitle",
+    "Titlehead",
+    "Typearea",
+    "Uppertitleback",
+    "Usekomafont",
+    "commands",
+]

pytex_koma/commands.py

@@ -0,0 +1,296 @@
+from pytex.helpers.with_package import with_package
+from pytex.interface.tex import TeX
+from pytex.model.control_sequence import ControlSequence, Parameter
+from pytex.model.environment import Environment
+from pytex.packages import SCRLAYER_SCRPAGE, TYPEAREA
+from pytex.registry import Registry
+
+__all__ = [
+    "Addchap",
+    "Addmargin",
+    "Addpart",
+    "Addsec",
+    "Addtokomafont",
+    "Appendix",
+    "Areaset",
+    "Automark",
+    "Backmatter",
+    "Captionabove",
+    "Captionbelow",
+    "Cfoot",
+    "Chead",
+    "Clearpairofpagestyles",
+    "Clearscrheadfoot",
+    "Dedication",
+    "Dictum",
+    "Extratitle",
+    "Frontmatter",
+    "Ifoot",
+    "Ihead",
+    "KOMAoption",
+    "KOMAoptions",
+    "Labeling",
+    "Lowertitleback",
+    "Mainmatter",
+    "Marginline",
+    "Minisec",
+    "Ofoot",
+    "Ohead",
+    "Pagestyle",
+    "Publishers",
+    "Recalctypearea",
+    "Setkomafont",
+    "Subject",
+    "Subtitle",
+    "Titlehead",
+    "Typearea",
+    "Uppertitleback",
+    "Usekomafont",
+]
+
+
+def _sectioning(name: str, title: TeX | str, short: TeX | str | None) -> TeX:
+    if short is None:
+        return ControlSequence(name, (Parameter(title),))
+    return ControlSequence(name, (Parameter(short, optional=True), Parameter(title)))
+
+
+@Registry.add
+def Addpart(title: TeX | str, short: TeX | str | None = None) -> TeX:
+    return _sectioning("addpart", title, short)
+
+
+@Registry.add
+def Addchap(title: TeX | str, short: TeX | str | None = None) -> TeX:
+    return _sectioning("addchap", title, short)
+
+
+@Registry.add
+def Addsec(title: TeX | str, short: TeX | str | None = None) -> TeX:
+    return _sectioning("addsec", title, short)
+
+
+@Registry.add
+def Minisec(title: TeX | str) -> TeX:
+    return ControlSequence("minisec", (Parameter(title),))
+
+
+@Registry.add
+def Frontmatter() -> TeX:
+    return ControlSequence("frontmatter", ())
+
+
+@Registry.add
+def Mainmatter() -> TeX:
+    return ControlSequence("mainmatter", ())
+
+
+@Registry.add
+def Backmatter() -> TeX:
+    return ControlSequence("backmatter", ())
+
+
+@Registry.add
+def Appendix() -> TeX:
+    return ControlSequence("appendix", ())
+
+
+@Registry.add
+def Subtitle(text: TeX | str) -> TeX:
+    return ControlSequence("subtitle", (Parameter(text),))
+
+
+@Registry.add
+def Subject(text: TeX | str) -> TeX:
+    return ControlSequence("subject", (Parameter(text),))
+
+
+@Registry.add
+def Publishers(text: TeX | str) -> TeX:
+    return ControlSequence("publishers", (Parameter(text),))
+
+
+@Registry.add
+def Titlehead(text: TeX | str) -> TeX:
+    return ControlSequence("titlehead", (Parameter(text),))
+
+
+@Registry.add
+def Dedication(text: TeX | str) -> TeX:
+    return ControlSequence("dedication", (Parameter(text),))
+
+
+@Registry.add
+def Uppertitleback(text: TeX | str) -> TeX:
+    return ControlSequence("uppertitleback", (Parameter(text),))
+
+
+@Registry.add
+def Lowertitleback(text: TeX | str) -> TeX:
+    return ControlSequence("lowertitleback", (Parameter(text),))
+
+
+@Registry.add
+def Extratitle(text: TeX | str) -> TeX:
+    return ControlSequence("extratitle", (Parameter(text),))
+
+
+@Registry.add
+def Dictum(text: TeX | str, author: TeX | str | None = None) -> TeX:
+    if author is None:
+        return ControlSequence("dictum", (Parameter(text),))
+    return ControlSequence(
+        "dictum",
+        (Parameter(author, optional=True), Parameter(text)),
+    )
+
+
+@Registry.add
+def KOMAoptions(options: dict[str, str]) -> TeX:
+    return ControlSequence("KOMAoptions", (Parameter(options),))
+
+
+@Registry.add
+def KOMAoption(key: str, value: str) -> TeX:
+    return ControlSequence("KOMAoption", (Parameter(key), Parameter(value)))
+
+
+@Registry.add
+def Setkomafont(element: str, definition: TeX | str) -> TeX:
+    return ControlSequence(
+        "setkomafont",
+        (Parameter(element), Parameter(definition)),
+    )
+
+
+@Registry.add
+def Addtokomafont(element: str, definition: TeX | str) -> TeX:
+    return ControlSequence(
+        "addtokomafont",
+        (Parameter(element), Parameter(definition)),
+    )
+
+
+@Registry.add
+def Usekomafont(element: str) -> TeX:
+    return ControlSequence("usekomafont", (Parameter(element),))
+
+
+@Registry.add
+def Captionabove(text: TeX | str) -> TeX:
+    return ControlSequence("captionabove", (Parameter(text),))
+
+
+@Registry.add
+def Captionbelow(text: TeX | str) -> TeX:
+    return ControlSequence("captionbelow", (Parameter(text),))
+
+
+@Registry.add
+def Marginline(text: TeX | str) -> TeX:
+    return ControlSequence("marginline", (Parameter(text),))
+
+
+@Registry.add
+def Addmargin(body: TeX | str, amount: str) -> TeX:
+    return Environment("addmargin", body, (Parameter(amount),))
+
+
+@Registry.add
+def Labeling(body: TeX | str, sep: str = "") -> TeX:
+    params = (Parameter(sep, optional=True),) if sep else ()
+    return Environment("labeling", body, params)
+
+
+@Registry.add
+@with_package(TYPEAREA)
+def Areaset(width: str, height: str, bcor: str | None = None) -> TeX:
+    if bcor is None:
+        return ControlSequence("areaset", (Parameter(width), Parameter(height)))
+    return ControlSequence(
+        "areaset",
+        (Parameter(bcor, optional=True), Parameter(width), Parameter(height)),
+    )
+
+
+@Registry.add
+@with_package(TYPEAREA)
+def Typearea(divisor: int | str) -> TeX:
+    return ControlSequence("typearea", (Parameter(str(divisor)),))
+
+
+@Registry.add
+@with_package(TYPEAREA)
+def Recalctypearea() -> TeX:
+    return ControlSequence("recalctypearea", ())
+
+
+@Registry.add
+@with_package(SCRLAYER_SCRPAGE)
+def Pagestyle(name: str) -> TeX:
+    return ControlSequence("pagestyle", (Parameter(name),))
+
+
+@Registry.add
+@with_package(SCRLAYER_SCRPAGE)
+def Clearpairofpagestyles() -> TeX:
+    return ControlSequence("clearpairofpagestyles", ())
+
+
+@Registry.add
+@with_package(SCRLAYER_SCRPAGE)
+def Clearscrheadfoot() -> TeX:
+    return ControlSequence("clearscrheadfoot", ())
+
+
+@Registry.add
+@with_package(SCRLAYER_SCRPAGE)
+def Automark(level: str, second: str | None = None) -> TeX:
+    if second is None:
+        return ControlSequence("automark", (Parameter(level),))
+    return ControlSequence(
+        "automark",
+        (Parameter(second, optional=True), Parameter(level)),
+    )
+
+
+def _scoped_head_foot(name: str, scope: str | None, body: TeX | str) -> TeX:
+    if scope is None:
+        return ControlSequence(name, (Parameter(body),))
+    return ControlSequence(name, (Parameter(scope, optional=True), Parameter(body)))
+
+
+@Registry.add
+@with_package(SCRLAYER_SCRPAGE)
+def Ihead(body: TeX | str, scope: str | None = None) -> TeX:
+    return _scoped_head_foot("ihead", scope, body)
+
+
+@Registry.add
+@with_package(SCRLAYER_SCRPAGE)
+def Chead(body: TeX | str, scope: str | None = None) -> TeX:
+    return _scoped_head_foot("chead", scope, body)
+
+
+@Registry.add
+@with_package(SCRLAYER_SCRPAGE)
+def Ohead(body: TeX | str, scope: str | None = None) -> TeX:
+    return _scoped_head_foot("ohead", scope, body)
+
+
+@Registry.add
+@with_package(SCRLAYER_SCRPAGE)
+def Ifoot(body: TeX | str, scope: str | None = None) -> TeX:
+    return _scoped_head_foot("ifoot", scope, body)
+
+
+@Registry.add
+@with_package(SCRLAYER_SCRPAGE)
+def Cfoot(body: TeX | str, scope: str | None = None) -> TeX:
+    return _scoped_head_foot("cfoot", scope, body)
+
+
+@Registry.add
+@with_package(SCRLAYER_SCRPAGE)
+def Ofoot(body: TeX | str, scope: str | None = None) -> TeX:
+    return _scoped_head_foot("ofoot", scope, body)

pytex_koma/document.py

@@ -0,0 +1,138 @@
+# pyright: reportAny=false
+from collections.abc import Iterator
+from dataclasses import dataclass, field
+
+from pytex.interface.package import PackageOption
+from pytex.model.document import Document
+from pytex.registry import Registry
+
+__all__ = ["KomaDocument"]
+
+KOMA_CLASSES: frozenset[str] = frozenset(
+    {"scrartcl", "scrreprt", "scrbook", "scrlttr2"}
+)
+
+PAPER_FLAGS: frozenset[str] = frozenset(
+    {"a4paper", "a5paper", "b5paper", "letterpaper", "executivepaper", "legalpaper"}
+)
+FONTSIZE_FLAGS: frozenset[str] = frozenset({"10pt", "11pt", "12pt"})
+
+
+def _on_off(value: bool, on: str, off: str) -> str:
+    return on if value else off
+
+
+@Registry.add
+@dataclass
+class KomaDocument(Document):
+    document_class: str = "scrartcl"
+
+    paper: str | None = None
+    fontsize: str | None = None
+    bcor: str | None = None
+    div: int | str | None = None
+    pagesize: str | None = None
+
+    two_side: bool | None = None
+    two_column: bool | None = None
+    landscape: bool | None = None
+    title_page: bool | None = None
+    draft: bool | None = None
+
+    open_at: str | None = None
+    chapter_prefix: bool | None = None
+    appendix_prefix: bool | None = None
+
+    headings: str | None = None
+    parskip: str | None = None
+    numbers: str | None = None
+    captions: str | None = None
+    toc: str | None = None
+    listof: str | None = None
+    bibliography: str | None = None
+    index: str | None = None
+    footnotes: str | None = None
+
+    head_include: bool | None = None
+    foot_include: bool | None = None
+    mp_include: bool | None = None
+
+    use_geometry: bool | None = None
+
+    extra_class_options: set[PackageOption] = field(default_factory=set)
+
+    def __post_init__(self) -> None:
+        super().__post_init__()
+        if self.document_class not in KOMA_CLASSES:
+            raise ValueError(
+                f"Unknown KOMA-Script class {self.document_class!r}; "
+                + f"expected one of {sorted(KOMA_CLASSES)}"
+            )
+        self.document_class_options: set[PackageOption] = (
+            set(self.document_class_options)
+            | set(self.extra_class_options)
+            | set(self._class_option_flags())
+        )
+
+    def _class_option_flags(self) -> Iterator[PackageOption]:
+        """Translate the typed KOMA fields into raw class options."""
+        # Value-bearing options: a known keyword flag, otherwise a key=value pair.
+        if self.paper is not None:
+            yield self.paper if self.paper in PAPER_FLAGS else ("paper", self.paper)
+        if self.fontsize is not None:
+            yield (
+                self.fontsize
+                if self.fontsize in FONTSIZE_FLAGS
+                else ("fontsize", self.fontsize)
+            )
+        if self.bcor is not None:
+            yield ("BCOR", self.bcor)
+        if self.div is not None:
+            yield ("DIV", str(self.div))
+        if self.pagesize is not None:
+            yield ("pagesize", self.pagesize)
+
+        # Boolean toggles mapped to their on/off keywords.
+        if self.two_side is not None:
+            yield _on_off(self.two_side, "twoside", "oneside")
+        if self.two_column is not None:
+            yield _on_off(self.two_column, "twocolumn", "onecolumn")
+        if self.landscape is True:
+            yield "landscape"
+        if self.title_page is not None:
+            yield _on_off(self.title_page, "titlepage", "notitlepage")
+        if self.draft is not None:
+            yield _on_off(self.draft, "draft", "final")
+
+        if self.open_at is not None:
+            yield ("open", self.open_at)
+        if self.chapter_prefix is not None:
+            yield ("chapterprefix", _on_off(self.chapter_prefix, "true", "false"))
+        if self.appendix_prefix is not None:
+            yield ("appendixprefix", _on_off(self.appendix_prefix, "true", "false"))
+
+        # Plain key=value options taken verbatim from same-named fields.
+        for key in (
+            "headings",
+            "parskip",
+            "numbers",
+            "captions",
+            "toc",
+            "listof",
+            "bibliography",
+            "index",
+            "footnotes",
+        ):
+            value = getattr(self, key)
+            if value is not None:
+                yield (key, value)
+
+        if self.head_include is not None:
+            yield "headinclude" if self.head_include else "headexclude"
+        if self.foot_include is not None:
+            yield "footinclude" if self.foot_include else "footexclude"
+        if self.mp_include is not None:
+            yield "mpinclude" if self.mp_include else "mpexclude"
+
+        if self.use_geometry is not None:
+            yield "usegeometry" if self.use_geometry else "nogeometry"

pytex_markdown/__init__.py

@@ -0,0 +1,62 @@
+"""Markdown -> native PyTeX conversion.
+
+Exposes two registered factories:
+
+* ``Markdown(content, ...)``        - convert a Markdown string to a ``TeX`` tree.
+* ``IncludeMarkdown(path, ...)``    - read a file and convert it.
+
+GitHub-style callouts (``> [!NOTE]`` ...) become HSRT ``ColoredBox`` presets,
+so this package depends on ``pytex_hsrtreport``.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import marko
+
+from pytex.registry import Registry
+
+from .convert import MarkdownConverter
+from .escape import escape_latex
+
+if TYPE_CHECKING:
+    from os import PathLike
+
+    from pytex.interface.tex import TeX
+
+__all__ = ["IncludeMarkdown", "Markdown", "MarkdownConverter", "escape_latex"]
+
+PARSER = marko.Markdown()
+
+
+@Registry.add
+def Markdown(
+    content: str,
+    *,
+    base_level: int = 0,
+    callouts: bool = True,
+) -> TeX:
+    """Convert a Markdown string to a ``TeX`` tree.
+
+    ``base_level`` shifts heading depth: ``0`` maps ``#`` to ``\\section`` (the
+    default), ``-1`` maps it to ``\\chapter``. ``callouts`` toggles converting
+    ``> [!NOTE]`` blocks into HSRT colored boxes.
+    """
+    ast = PARSER.parse(content)
+    converter = MarkdownConverter(base_level=base_level, callouts=callouts)
+    return converter.block(ast)
+
+
+@Registry.add
+def IncludeMarkdown(
+    path: str | PathLike[str],
+    *,
+    base_level: int = 0,
+    callouts: bool = True,
+    encoding: str = "utf-8",
+) -> TeX:
+    """Read a Markdown file and convert it (see :func:`Markdown`)."""
+    content = Path(path).read_text(encoding=encoding)
+    return Markdown(content, base_level=base_level, callouts=callouts)