pytex-preprocessor 0.4.2__tar.gz → 0.4.4__tar.gz

{pytex_preprocessor-0.4.2/src/pytex_preprocessor.egg-info → pytex_preprocessor-0.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytex-preprocessor
-Version: 0.4.2
+Version: 0.4.4
 Summary: Type-safe LaTeX document generation with Python
 Author-email: Frederik Beimgraben <frederik@beimgraben.net>
 License:                     GNU GENERAL PUBLIC LICENSE

{pytex_preprocessor-0.4.2 → pytex_preprocessor-0.4.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pytex-preprocessor"
-version = "0.4.2"
+version = "0.4.4"
 authors = [
   { name="Frederik Beimgraben", email="frederik@beimgraben.net" },
 ]

{pytex_preprocessor-0.4.2 → pytex_preprocessor-0.4.4}/src/pytex/commands/builtin.py

@@ -1,8 +1,10 @@
+from ..helpers.with_package import with_package
 from ..interface.tex import TeX
 from ..model.concat import Concat
 from ..model.control_sequence import ControlSequence, Parameter
 from ..model.environment import Environment
 from ..model.raw import Raw
+from ..packages import EUROSYM
 from ..registry import Registry
 
 __all__ = [
@@ -24,6 +26,7 @@ __all__ = [
     "Emph",
     "EndAccSupp",
     "Enumerate",
+    "Euro",
     "FlushLeft",
     "FlushRight",
     "Footnote",
@@ -235,6 +238,18 @@ def Newline() -> TeX:
     return Raw("\\\\")
 
 
+@Registry.add
+@with_package(EUROSYM)
+def Euro() -> TeX:
+    """Euro sign via ``eurosym``'s ``\\euro{}``.
+
+    eurosym ships its own glyph, so it renders even when the text font (e.g.
+    DIN) has no euro glyph. The trailing empty group stops the macro from
+    gobbling a following space, keeping ``50\\euro{} each`` spaced correctly.
+    """
+    return ControlSequence("euro", (Parameter(Raw("")),))
+
+
 @Registry.add
 def Linebreak(n: int | None = None) -> TeX:
     if n is None:

{pytex_preprocessor-0.4.2 → pytex_preprocessor-0.4.4}/src/pytex/helpers/sanitize.py

@@ -34,6 +34,11 @@ ESCAPES: Final[dict[str, str]] = {
     "}": r"\}",
     "~": r"\textasciitilde{}",
     "^": r"\textasciicircum{}",
+    # babel ngerman (always loaded) makes `"` an active shorthand char, so a
+    # literal double quote would be swallowed/mangled. `\textquotedbl{}` is a
+    # font-encoding macro (T1/textcomp), not a shorthand, so it prints an
+    # upright double quote untouched; the empty group stops space-gobbling.
+    '"': r"\textquotedbl{}",
 }
 
 

{pytex_preprocessor-0.4.2 → pytex_preprocessor-0.4.4}/src/pytex/packages.py

@@ -113,6 +113,9 @@ ARYDSHLN: Package = DefinePackage("arydshln")
 LMODERN: Package = DefinePackage("lmodern")
 HYPHENAT: Package = DefinePackage("hyphenat")
 FP: Package = DefinePackage("fp")
+# Ships its own euro glyph, so `\euro{}` renders independent of the text font
+# (e.g. DIN, whose font set lacks a euro glyph and would otherwise tofu).
+EUROSYM: Package = DefinePackage("eurosym")
 
 
 class Packages(Enum):
@@ -219,3 +222,4 @@ class Packages(Enum):
     LMODERN = LMODERN
     HYPHENAT = HYPHENAT
     FP = FP
+    EUROSYM = EUROSYM

{pytex_preprocessor-0.4.2 → pytex_preprocessor-0.4.4}/src/pytex_builder/variants.py

@@ -26,6 +26,7 @@ from pytex.model.concat import Concat
 from pytex.model.document import Document
 from pytex.model.raw import Raw
 from pytex_hsrtreport.document import HSRTReport
+from pytex_hsrtreport.titlepage import TitlePageDataLine
 from pytex_hsrtreport.variants import Variant
 from pytex_markdown import Markdown, escape_latex
 from pytex_protocol.document import build_protocol
@@ -108,6 +109,9 @@ def _report(body: str, options: dict[str, object]) -> TeX:
         show_toc=True,
         title=escape_latex(title) if title is not None else None,
         author=_escaped(_str(options, "author", "autor")),
+        abstract=_escaped(_str(options, "abstract", "zusammenfassung")),
+        keywords=_escaped(_keywords(options)),
+        data_lines=_data_lines(options),
         # Map the shallowest heading in the body to \chapter, so headings nest
         # under it. Without this, a doc whose top level is `##` (because `#` was
         # consumed as the title) would render chapterless sections numbered 0.x.
@@ -153,6 +157,43 @@ def _escaped(value: str | None) -> str | None:
     return escape_latex(value) if value is not None else None
 
 
+def _keywords(options: Mapping[str, object]) -> str | None:
+    """Title-page keywords from `keywords`/`schlagworte` (string or list)."""
+    for key in ("keywords", "schlagworte"):
+        value = options.get(key)
+        if isinstance(value, list) and value:
+            return ", ".join(str(item) for item in value)  # pyright: ignore[reportUnknownVariableType, reportUnknownArgumentType]
+        if isinstance(value, str) and value:
+            return value
+    return None
+
+
+def _data_lines(options: Mapping[str, object]) -> tuple[TitlePageDataLine, ...]:
+    """Title-page data table from `datalines`/`data`.
+
+    Each entry is a ``"Label: value"`` string (frontmatter has no nested maps),
+    given as a block list, flow list, or a single scalar. Entries without a
+    colon are skipped.
+    """
+    raw = options.get("datalines", options.get("data"))
+    if isinstance(raw, list):
+        items = [str(item) for item in raw]  # pyright: ignore[reportUnknownVariableType, reportUnknownArgumentType]
+    elif isinstance(raw, str) and raw:
+        items = [raw]
+    else:
+        return ()
+    lines: list[TitlePageDataLine] = []
+    for item in items:
+        label, sep, value = item.partition(":")
+        if sep and label.strip():
+            lines.append(
+                TitlePageDataLine(
+                    escape_latex(label.strip()), escape_latex(value.strip())
+                )
+            )
+    return tuple(lines)
+
+
 def _derive_title(body: str) -> tuple[str | None, str]:
     """Pull the first ATX `#` heading out of `body` to use as the title.
 

{pytex_preprocessor-0.4.2 → pytex_preprocessor-0.4.4}/src/pytex_markdown/convert.py

@@ -10,6 +10,7 @@ this module depends on ``pytex_hsrtreport``.
 from __future__ import annotations
 
 import re
+from pathlib import Path
 from typing import TYPE_CHECKING, Any, Final, cast
 
 from pytex.commands.builtin import (
@@ -17,6 +18,7 @@ from pytex.commands.builtin import (
     Chapter,
     Emph,
     Enumerate,
+    Euro,
     Itemize,
     Newline,
     Noindent,
@@ -101,6 +103,11 @@ CALLOUTS: Final[dict[str, Callable[[TeX | str], TeX]]] = {
     "ERROR": WarningBox,
 }
 
+# U+20AC EURO SIGN. The DIN text font has no euro glyph, so the raw char would
+# render as tofu; we splice in a real ``Euro`` node (eurosym ``\euro{}``) which
+# ships its own glyph and registers the package requirement.
+EURO_SIGN: Final[str] = "€"
+
 PARBREAK: Final[TeX] = Raw("\n\n")
 
 # GFM cell alignment -> tabularx ``X`` column spec. ``X`` columns share the
@@ -146,6 +153,26 @@ def _escape_text(text: str) -> str:
     return "".join(out)
 
 
+def _prose(text: str) -> TeX:
+    """Escape prose, splitting literal euro signs into ``Euro`` nodes.
+
+    Each ``€`` becomes a real :func:`Euro` node (eurosym ``\\euro{}``) instead
+    of a raw char so the preamble auto-loads ``eurosym`` and the glyph renders
+    even under the DIN font. Text between the euros keeps its arrow/escape
+    handling, and the split preserves surrounding spacing exactly (e.g. ``50€``
+    stays glyph-adjacent, ``€ 50`` keeps its space).
+    """
+    if EURO_SIGN not in text:
+        return Raw(_escape_text(text))
+    parts: list[TeX] = []
+    for i, segment in enumerate(text.split(EURO_SIGN)):
+        if i:
+            parts.append(Euro())
+        if segment:
+            parts.append(Raw(_escape_text(segment)))
+    return Concat(*parts)
+
+
 class MarkdownConverter:
     """Walk a marko AST, producing a single ``TeX`` tree.
 
@@ -169,7 +196,7 @@ class MarkdownConverter:
             # RawText / CodeSpan / Literal etc. carry a plain string.
             if kind == "CodeSpan":
                 return Texttt(Raw(escape_latex(text)))
-            return Raw(_escape_text(text))
+            return _prose(text)
 
         if kind == "StrongEmphasis":
             return Bold(self.inlines(node))
@@ -182,7 +209,14 @@ class MarkdownConverter:
             # Relative/local/anchor target: keep the text, drop the dead link.
             return self.inlines(node)
         if kind == "Image":
-            return IncludeImage(str(getattr(node, "dest", "")))
+            dest = str(getattr(node, "dest", ""))
+            if EXTERNAL_URL_RE.match(dest):
+                return IncludeImage(dest)
+            # The .tex is compiled in the build dir, not next to the Markdown
+            # source, so a relative path would not resolve. Make it absolute
+            # (relative to the CWD the build runs from) so \includegraphics
+            # finds the file without copying or base64-embedding it.
+            return IncludeImage(str(Path(dest).resolve()))
         if kind == "LineBreak":
             # Hard break -> newline; soft break -> a plain space.
             soft = bool(getattr(node, "soft", False))
@@ -238,7 +272,7 @@ class MarkdownConverter:
         # Rebuild the first paragraph with the marker stripped, keep the rest.
         stripped = first_text[match.end() :]
         head = Concat(
-            Raw(_escape_text(stripped)),
+            _prose(stripped),
             *(self.inline(c) for c in inner[1:]),
         )
         body_blocks = [head, *(self.block(b) for b in kids[1:])]

{pytex_preprocessor-0.4.2 → pytex_preprocessor-0.4.4/src/pytex_preprocessor.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytex-preprocessor
-Version: 0.4.2
+Version: 0.4.4
 Summary: Type-safe LaTeX document generation with Python
 Author-email: Frederik Beimgraben <frederik@beimgraben.net>
 License:                     GNU GENERAL PUBLIC LICENSE