Added PDF output (codex)

pdf_builder.py

@@ -0,0 +1,295 @@
+"""Local Markdown to PDF rendering."""
+
+from __future__ import annotations
+
+import html
+import re
+import shutil
+import subprocess
+import tempfile
+from pathlib import Path
+
+
+_IMAGE_RE = re.compile(r"^!\[([^]]*)\]\((?:<([^>]+)>|([^\s)]+))\)$")
+_HEADING_RE = re.compile(r"^(#{1,6})\s+(.+)$")
+_ORDERED_RE = re.compile(r"^\d+[.)]\s+(.+)$")
+_UNORDERED_RE = re.compile(r"^[-*+]\s+(.+)$")
+_MATH_RE = re.compile(r"(\$\$.+?\$\$|(?<!\\)\$(?!\$).+?(?<!\\)\$)", re.DOTALL)
+_BOLD_RE = re.compile(r"\*\*(.+?)\*\*", re.DOTALL)
+_LINK_RE = re.compile(r"\[([^]]+)]\(([^)]+)\)")
+
+
+class PdfBuilder:
+    """Render the Markdown subset produced by MarkdownBuilder as a styled PDF."""
+
+    def __init__(self, browser: str | None = None) -> None:
+        self._browser = browser
+
+    @staticmethod
+    def _render_math(source: str, *, display: bool) -> str:
+        try:
+            from latex2mathml.converter import convert
+        except ImportError as error:
+            raise RuntimeError(
+                "PDF formulas require latex2mathml: pip install latex2mathml"
+            ) from error
+
+        try:
+            mathml = convert(source.strip())
+        except Exception as error:
+            raise ValueError(f"Invalid LaTeX formula: {source}") from error
+        css_class = "math display" if display else "math inline"
+        return f'<span class="{css_class}">{mathml}</span>'
+
+    @classmethod
+    def _render_plain_inline(cls, source: str) -> str:
+        parts: list[str] = []
+        cursor = 0
+        for match in _BOLD_RE.finditer(source):
+            parts.append(html.escape(source[cursor:match.start()]))
+            parts.append(f"<strong>{html.escape(match.group(1))}</strong>")
+            cursor = match.end()
+        parts.append(html.escape(source[cursor:]))
+        rendered = "".join(parts)
+
+        def link(match: re.Match[str]) -> str:
+            label = html.escape(match.group(1))
+            target = html.escape(match.group(2), quote=True)
+            return f'<a href="{target}">{label}</a>'
+
+        return _LINK_RE.sub(link, rendered)
+
+    @classmethod
+    def _render_inline(cls, source: str) -> str:
+        result: list[str] = []
+        cursor = 0
+        for match in _MATH_RE.finditer(source):
+            result.append(cls._render_plain_inline(source[cursor:match.start()]))
+            token = match.group(0)
+            display = token.startswith("$$")
+            formula = token[2:-2] if display else token[1:-1]
+            result.append(cls._render_math(formula, display=display))
+            cursor = match.end()
+        result.append(cls._render_plain_inline(source[cursor:]))
+        return "".join(result)
+
+    @staticmethod
+    def _image_uri(markdown_path: Path, image_path: str) -> str:
+        path = Path(image_path)
+        if not path.is_absolute():
+            path = markdown_path.parent / path
+        path = path.resolve()
+        if not path.is_file():
+            raise FileNotFoundError(f"Markdown image not found: {path}")
+        return path.as_uri()
+
+    @classmethod
+    def _render_blocks(cls, markdown: str, markdown_path: Path) -> str:
+        lines = markdown.splitlines()
+        blocks: list[str] = []
+        index = 0
+        first_heading = True
+
+        while index < len(lines):
+            line = lines[index].strip()
+            if not line:
+                index += 1
+                continue
+
+            heading = _HEADING_RE.match(line)
+            if heading:
+                level = min(len(heading.group(1)), 4)
+                title_class = ' class="document-title"' if first_heading else ""
+                blocks.append(
+                    f"<h{level}{title_class}>"
+                    f"{cls._render_inline(heading.group(2))}</h{level}>"
+                )
+                first_heading = False
+                index += 1
+                continue
+
+            image = _IMAGE_RE.match(line)
+            if image:
+                alt = image.group(1).strip()
+                source = image.group(2) or image.group(3)
+                uri = cls._image_uri(markdown_path, source)
+                caption = (
+                    f"<figcaption>{cls._render_inline(alt)}</figcaption>"
+                    if alt else ""
+                )
+                blocks.append(
+                    "<figure>"
+                    f'<img src="{html.escape(uri, quote=True)}" alt="{html.escape(alt, quote=True)}">'
+                    f"{caption}</figure>"
+                )
+                index += 1
+                continue
+
+            if line.startswith(">"):
+                quote: list[str] = []
+                while index < len(lines) and lines[index].lstrip().startswith(">"):
+                    quote.append(lines[index].lstrip()[1:].strip())
+                    index += 1
+                blocks.append(
+                    f"<blockquote>{cls._render_inline(' '.join(quote))}</blockquote>"
+                )
+                continue
+
+            ordered = _ORDERED_RE.match(line)
+            unordered = _UNORDERED_RE.match(line)
+            if ordered or unordered:
+                pattern = _ORDERED_RE if ordered else _UNORDERED_RE
+                tag = "ol" if ordered else "ul"
+                items: list[str] = []
+                while index < len(lines):
+                    item = pattern.match(lines[index].strip())
+                    if not item:
+                        break
+                    items.append(f"<li>{cls._render_inline(item.group(1))}</li>")
+                    index += 1
+                blocks.append(f"<{tag}>{''.join(items)}</{tag}>")
+                continue
+
+            if line.startswith("$$") and line.endswith("$$") and len(line) > 4:
+                blocks.append(cls._render_math(line[2:-2], display=True))
+                index += 1
+                continue
+
+            paragraph = [line]
+            index += 1
+            while index < len(lines) and lines[index].strip():
+                candidate = lines[index].strip()
+                if (
+                    _HEADING_RE.match(candidate)
+                    or _IMAGE_RE.match(candidate)
+                    or candidate.startswith(">")
+                    or _ORDERED_RE.match(candidate)
+                    or _UNORDERED_RE.match(candidate)
+                ):
+                    break
+                paragraph.append(candidate)
+                index += 1
+            blocks.append(f"<p>{cls._render_inline(' '.join(paragraph))}</p>")
+
+        return "\n".join(blocks)
+
+    @staticmethod
+    def _document(body: str, title: str) -> str:
+        return f"""<!doctype html>
+<html lang="ru">
+<head>
+<meta charset="utf-8">
+<title>{html.escape(title)}</title>
+<style>
+  @page {{
+    size: A4;
+    margin: 19mm 18mm 20mm;
+    @bottom-center {{
+      content: "SUMKA  ·  " counter(page);
+      color: #718096;
+      font: 8.5pt "Ubuntu", "DejaVu Sans", sans-serif;
+      letter-spacing: .08em;
+    }}
+  }}
+  * {{ box-sizing: border-box; }}
+  html {{ color: #172033; font-family: "Ubuntu", "DejaVu Sans", sans-serif; }}
+  body {{ margin: 0; font-size: 10.7pt; line-height: 1.62; }}
+  h1, h2, h3, h4 {{ color: #102a43; line-height: 1.22; break-after: avoid; }}
+  h1 {{ font-size: 28pt; }}
+  h2 {{ font-size: 21pt; margin: 1.2em 0 .55em; }}
+  h3 {{ font-size: 15.5pt; margin: 1.45em 0 .5em; padding-bottom: .22em;
+        border-bottom: 1px solid #d9e2ec; }}
+  h4 {{ font-size: 12.5pt; margin: 1.25em 0 .4em; color: #1f5f8b; }}
+  .document-title {{ margin: 0 0 1.15em; padding: .75em .9em .8em;
+      border-left: 5px solid #2f80ed;
+      background: linear-gradient(120deg, #eef6ff, #f8fbff 70%);
+      border-radius: 0 10px 10px 0; }}
+  p {{ margin: 0 0 .85em; text-align: justify; hyphens: auto; orphans: 3; widows: 3; }}
+  strong {{ color: #0f3557; font-weight: 700; }}
+  ul, ol {{ margin: .3em 0 1em; padding-left: 1.55em; }}
+  li {{ margin: .24em 0; padding-left: .2em; }}
+  li::marker {{ color: #2f80ed; font-weight: 700; }}
+  blockquote {{ margin: 1.1em 0; padding: .8em 1em .8em 1.15em;
+      border-left: 4px solid #f2b84b; background: #fff8e8; color: #483b22;
+      border-radius: 0 8px 8px 0; break-inside: avoid; }}
+  figure {{ margin: 1.25em auto 1.45em; text-align: center; break-inside: avoid; }}
+  figure img {{ display: block; max-width: 100%; max-height: 188mm; margin: auto;
+      object-fit: contain; border: 1px solid #d9e2ec; border-radius: 7px;
+      box-shadow: 0 5px 18px rgba(23, 32, 51, .12); }}
+  figcaption {{ margin: .55em auto 0; max-width: 88%; color: #637083;
+      font-size: 8.7pt; line-height: 1.4; }}
+  .math.inline {{ display: inline-block; white-space: nowrap; vertical-align: -.12em; }}
+  .math.display {{ display: block; margin: 1.1em auto; padding: .75em 1em;
+      overflow: hidden; text-align: center; background: #f6f9fc;
+      border: 1px solid #e3eaf2; border-radius: 7px; break-inside: avoid; }}
+  math {{ font-family: "STIX Two Math", "STIX Math", "Cambria Math", serif; }}
+  a {{ color: #1769aa; text-decoration: none; }}
+</style>
+</head>
+<body>{body}</body>
+</html>
+"""
+
+    def _find_browser(self) -> str:
+        if self._browser:
+            browser = shutil.which(self._browser) or self._browser
+            if Path(browser).is_file():
+                return browser
+            raise RuntimeError(f"PDF browser not found: {self._browser}")
+
+        for candidate in (
+            "chromium",
+            "chromium-browser",
+            "google-chrome",
+            "google-chrome-stable",
+        ):
+            browser = shutil.which(candidate)
+            if browser:
+                return browser
+        raise RuntimeError("PDF generation requires Chromium or Google Chrome")
+
+    def build(self, markdown_path: str | Path, output_path: str | Path) -> None:
+        source = Path(markdown_path).resolve()
+        destination = Path(output_path).resolve()
+        if not source.is_file():
+            raise FileNotFoundError(f"Markdown file not found: {source}")
+
+        markdown = source.read_text(encoding="utf-8")
+        body = self._render_blocks(markdown, source)
+        title_match = re.search(r"^#{1,6}\s+(.+)$", markdown, re.MULTILINE)
+        title = title_match.group(1).replace("**", "") if title_match else "Конспект"
+        document = self._document(body, title)
+        browser = self._find_browser()
+        destination.parent.mkdir(parents=True, exist_ok=True)
+
+        with tempfile.TemporaryDirectory(prefix=".sumka-pdf-", dir=source.parent) as tmp:
+            workdir = Path(tmp)
+            html_path = workdir / "document.html"
+            html_path.write_text(document, encoding="utf-8")
+            command = [
+                browser,
+                "--headless",
+                "--disable-gpu",
+                "--disable-dev-shm-usage",
+                "--allow-file-access-from-files",
+                "--no-pdf-header-footer",
+                f"--user-data-dir={workdir / 'profile'}",
+                f"--print-to-pdf={destination}",
+                html_path.as_uri(),
+            ]
+            try:
+                result = subprocess.run(
+                    command,
+                    capture_output=True,
+                    text=True,
+                    timeout=120,
+                    check=False,
+                )
+            except subprocess.TimeoutExpired as error:
+                raise RuntimeError("Chromium timed out while generating PDF") from error
+
+            if result.returncode != 0 or not destination.is_file():
+                details = (result.stderr or result.stdout).strip()
+                raise RuntimeError(
+                    f"Chromium failed to generate PDF: {details or result.returncode}"
+                )