simpdf 0.1.0__py3-none-any.whl

simpdf/__init__.py

@@ -0,0 +1,11 @@
+from .fonts import DEJAVU_FONT_FILES, FontFace, download_dejavu_fonts
+from .renderer import MarkdownPdfRenderer, render_markdown_to_pdf_bytes, render_markdown_to_pdf_file
+
+__all__ = [
+    "DEJAVU_FONT_FILES",
+    "FontFace",
+    "MarkdownPdfRenderer",
+    "download_dejavu_fonts",
+    "render_markdown_to_pdf_bytes",
+    "render_markdown_to_pdf_file",
+]

simpdf/__main__.py

@@ -0,0 +1,5 @@
+from .cli import main
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

simpdf/cli.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+from .fonts import FontFace, download_dejavu_fonts
+from .renderer import MarkdownPdfRenderer
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="simpdf", description="Render Markdown into PDF with configurable TTF fonts.")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    render_parser = subparsers.add_parser("render", help="Render a Markdown file into PDF.")
+    render_parser.add_argument("input_markdown", type=Path)
+    render_parser.add_argument("output_pdf", type=Path)
+    render_parser.add_argument("--fonts-dir", type=Path, required=True)
+    render_parser.add_argument("--family-name", default="DejaVuSans")
+    render_parser.add_argument("--font-regular", required=True)
+    render_parser.add_argument("--font-bold")
+    render_parser.add_argument("--font-italic")
+    render_parser.add_argument("--font-bold-italic")
+    render_parser.add_argument("--options-file", type=Path, help="Path to a JSON file with formatting options.")
+
+    download_parser = subparsers.add_parser("download-dejavu", help="Download the DejaVu Sans font files.")
+    download_parser.add_argument("target_dir", type=Path)
+    download_parser.add_argument("--overwrite", action="store_true")
+
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+
+    if args.command == "download-dejavu":
+        download_dejavu_fonts(args.target_dir, overwrite=args.overwrite)
+        return 0
+
+    options = {}
+    if args.options_file:
+        options = json.loads(args.options_file.read_text(encoding="utf-8"))
+
+    renderer = MarkdownPdfRenderer(
+        font_directory=args.fonts_dir,
+        font_face=FontFace(
+            family=args.family_name,
+            regular=args.font_regular,
+            bold=args.font_bold,
+            italic=args.font_italic,
+            bold_italic=args.font_bold_italic,
+        ),
+        formatting_options=options,
+    )
+    markdown_text = args.input_markdown.read_text(encoding="utf-8")
+    renderer.render_to_file(markdown_text, args.output_pdf)
+    return 0

simpdf/fonts.py

@@ -0,0 +1,122 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Mapping
+from urllib.request import urlopen
+
+
+DEJAVU_BASE_URL = "https://github.com/shwars/simpdf/raw/refs/heads/main/fonts"
+DEJAVU_FONT_FILES = (
+    "DejaVuSans.ttf",
+    "DejaVuSans-Bold.ttf",
+    "DejaVuSans-Oblique.ttf",
+    "DejaVuSans-BoldOblique.ttf",
+    "DejaVuSansCondensed.ttf",
+    "DejaVuSansCondensed-Bold.ttf",
+    "DejaVuSansCondensed-Oblique.ttf",
+    "DejaVuSansCondensed-BoldOblique.ttf",
+)
+
+
+@dataclass(frozen=True)
+class FontFace:
+    family: str
+    regular: str
+    bold: str | None = None
+    italic: str | None = None
+    bold_italic: str | None = None
+
+    @classmethod
+    def dejavu_sans(cls) -> "FontFace":
+        return cls(
+            family="DejaVuSans",
+            regular="DejaVuSans.ttf",
+            bold="DejaVuSans-Bold.ttf",
+            italic="DejaVuSans-Oblique.ttf",
+            bold_italic="DejaVuSans-BoldOblique.ttf",
+        )
+
+
+def coerce_font_face(font_face: FontFace | Mapping[str, str]) -> FontFace:
+    if isinstance(font_face, FontFace):
+        return font_face
+
+    try:
+        family = font_face["family"]
+        regular = font_face["regular"]
+    except KeyError as exc:
+        raise ValueError(f"Missing required font face field: {exc.args[0]}") from exc
+
+    return FontFace(
+        family=family,
+        regular=regular,
+        bold=font_face.get("bold"),
+        italic=font_face.get("italic"),
+        bold_italic=font_face.get("bold_italic"),
+    )
+
+
+def resolve_font_paths(font_directory: str | Path, font_face: FontFace | Mapping[str, str]) -> dict[str, Path]:
+    directory = Path(font_directory)
+    face = coerce_font_face(font_face)
+    if not directory.exists():
+        raise FileNotFoundError(f"Font directory does not exist: {directory}")
+
+    regular = _resolve_path(directory, face.regular)
+    bold = _resolve_path(directory, face.bold) if face.bold else regular
+    italic = _resolve_path(directory, face.italic) if face.italic else regular
+    bold_italic = _resolve_path(directory, face.bold_italic) if face.bold_italic else bold
+
+    missing = [path for path in (regular, bold, italic, bold_italic) if not path.exists()]
+    if missing:
+        message = ", ".join(str(path) for path in missing)
+        raise FileNotFoundError(f"Missing required font files: {message}")
+
+    return {
+        "regular": regular,
+        "bold": bold,
+        "italic": italic,
+        "bold_italic": bold_italic,
+    }
+
+
+def register_font_family(pdf, font_directory: str | Path, font_face: FontFace | Mapping[str, str]) -> str:
+    face = coerce_font_face(font_face)
+    resolved = resolve_font_paths(font_directory, face)
+    pdf.add_font(face.family, style="", fname=str(resolved["regular"]))
+    pdf.add_font(face.family, style="B", fname=str(resolved["bold"]))
+    pdf.add_font(face.family, style="I", fname=str(resolved["italic"]))
+    pdf.add_font(face.family, style="BI", fname=str(resolved["bold_italic"]))
+    return face.family
+
+
+def download_dejavu_fonts(
+    target_dir: str | Path,
+    *,
+    overwrite: bool = False,
+    timeout: int = 30,
+) -> list[Path]:
+    target = Path(target_dir)
+    target.mkdir(parents=True, exist_ok=True)
+    downloaded: list[Path] = []
+
+    for filename in DEJAVU_FONT_FILES:
+        destination = target / filename
+        if destination.exists() and not overwrite:
+            downloaded.append(destination)
+            continue
+
+        url = f"{DEJAVU_BASE_URL}/{filename}"
+        with urlopen(url, timeout=timeout) as response:
+            destination.write_bytes(response.read())
+        downloaded.append(destination)
+
+    return downloaded
+
+
+def _resolve_path(base_dir: Path, value: str) -> Path:
+    path = Path(value)
+    if path.is_absolute():
+        return path
+    return base_dir / path

simpdf/markdown.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from markdown_it import MarkdownIt
+from markdown_it.tree import SyntaxTreeNode
+
+
+@dataclass(frozen=True)
+class InlineFragment:
+    text: str
+    bold: bool = False
+    italic: bool = False
+    code: bool = False
+    link: str | None = None
+
+
+def create_markdown_parser() -> MarkdownIt:
+    return MarkdownIt("commonmark", {"html": False, "linkify": True}).enable("table").enable("strikethrough")
+
+
+def parse_markdown_tree(text: str, parser: MarkdownIt | None = None) -> SyntaxTreeNode:
+    active_parser = parser or create_markdown_parser()
+    return SyntaxTreeNode(active_parser.parse(text or ""))
+
+
+def inline_fragments_from_node(node: SyntaxTreeNode) -> list[InlineFragment]:
+    return _collect_inline_fragments(node, bold=False, italic=False, code=False, link=None)
+
+
+def plain_text_from_node(node: SyntaxTreeNode) -> str:
+    return "".join(fragment.text for fragment in inline_fragments_from_node(node))
+
+
+def table_rows_from_node(table_node: SyntaxTreeNode) -> tuple[list[str], list[list[str]]]:
+    header: list[str] = []
+    rows: list[list[str]] = []
+
+    for child in table_node.children or []:
+        if child.type == "thead":
+            header = [_cell_text(cell) for row in child.children or [] for cell in row.children or []]
+        elif child.type == "tbody":
+            for row in child.children or []:
+                rows.append([_cell_text(cell) for cell in row.children or []])
+
+    return header, rows
+
+
+def _cell_text(cell_node: SyntaxTreeNode) -> str:
+    if not cell_node.children:
+        return ""
+    return plain_text_from_node(cell_node.children[0]).strip()
+
+
+def _collect_inline_fragments(
+    node: SyntaxTreeNode,
+    *,
+    bold: bool,
+    italic: bool,
+    code: bool,
+    link: str | None,
+) -> list[InlineFragment]:
+    node_type = node.type
+    if node_type == "text":
+        if not node.content:
+            return []
+        return [InlineFragment(text=node.content, bold=bold, italic=italic, code=code, link=link)]
+
+    if node_type in {"softbreak", "hardbreak"}:
+        return [InlineFragment(text="\n", bold=bold, italic=italic, code=code, link=link)]
+
+    if node_type == "code_inline":
+        return [InlineFragment(text=node.content, bold=bold, italic=italic, code=True, link=link)]
+
+    next_bold = bold or node_type == "strong"
+    next_italic = italic or node_type == "em"
+    next_link = node.attrs.get("href", link) if node_type == "link" else link
+
+    fragments: list[InlineFragment] = []
+    for child in node.children or []:
+        fragments.extend(
+            _collect_inline_fragments(
+                child,
+                bold=next_bold,
+                italic=next_italic,
+                code=code,
+                link=next_link,
+            )
+        )
+    return fragments

simpdf/options.py

@@ -0,0 +1,124 @@
+from __future__ import annotations
+
+from copy import deepcopy
+
+
+DEFAULT_FORMATTING_OPTIONS = {
+    "page": {
+        "format": "A4",
+        "orientation": "P",
+        "margins": {
+            "left": 15,
+            "top": 15,
+            "right": 15,
+            "bottom": 15,
+        },
+    },
+    "text": {
+        "font_size": 12,
+        "line_height": 1.5,
+        "color": (0, 0, 0),
+    },
+    "headings": {
+        "sizes": {
+            1: 22,
+            2: 20,
+            3: 18,
+            4: 16,
+            5: 14,
+            6: 12,
+        },
+        "line_height": 1.3,
+        "spacing_before": {
+            1: 2.0,
+            2: 1.8,
+            3: 1.6,
+            4: 1.4,
+            5: 1.2,
+            6: 1.0,
+        },
+        "spacing_after": {
+            1: 3.5,
+            2: 3.0,
+            3: 2.5,
+            4: 2.0,
+            5: 1.5,
+            6: 1.5,
+        },
+    },
+    "paragraph": {
+        "spacing_after": 3.0,
+    },
+    "lists": {
+        "indent": 7.0,
+        "bullet": "\u2022",
+        "item_spacing_after": 1.5,
+        "block_spacing_after": 1.5,
+    },
+    "blockquote": {
+        "indent": 8.0,
+        "bar_width": 0.8,
+        "bar_gap": 2.0,
+        "text_color": (90, 90, 90),
+        "spacing_after": 3.0,
+    },
+    "table": {
+        "font_size": 11,
+        "heading_font_size": 12,
+        "line_height": 6.0,
+        "cell_padding": 1.3,
+        "min_col_width": 24.0,
+        "spacing_after": 2.5,
+    },
+    "code_block": {
+        "font_size": 10,
+        "line_height": 5.5,
+        "padding": 2.0,
+        "background_color": (245, 245, 245),
+        "text_color": (40, 40, 40),
+        "spacing_after": 3.0,
+    },
+    "inline_code": {
+        "text_color": (120, 50, 20),
+    },
+    "links": {
+        "color": (0, 102, 204),
+        "underline": True,
+    },
+    "thematic_break": {
+        "spacing_before": 2.0,
+        "spacing_after": 4.0,
+        "width": 0.4,
+        "color": (160, 160, 160),
+    },
+}
+
+
+def merge_formatting_options(overrides: dict | None = None) -> dict:
+    merged = deepcopy(DEFAULT_FORMATTING_OPTIONS)
+    if overrides:
+        _deep_update(merged, overrides)
+    _normalize_heading_keys(merged.get("headings", {}))
+    return merged
+
+
+def _deep_update(target: dict, updates: dict) -> None:
+    for key, value in updates.items():
+        if isinstance(value, dict) and isinstance(target.get(key), dict):
+            _deep_update(target[key], value)
+            continue
+        target[key] = value
+
+
+def _normalize_heading_keys(headings: dict) -> None:
+    for key in ("sizes", "spacing_before", "spacing_after"):
+        values = headings.get(key)
+        if not isinstance(values, dict):
+            continue
+        normalized = {}
+        for subkey, value in values.items():
+            try:
+                normalized[int(subkey)] = value
+            except (TypeError, ValueError):
+                normalized[subkey] = value
+        headings[key] = normalized

simpdf/pdfgen.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from .fonts import FontFace
+from .renderer import MarkdownPdfRenderer
+
+_legacy_font_directory: Path | None = None
+_legacy_font_face = FontFace.dejavu_sans()
+
+
+def set_font_files(fonts_dir):
+    global _legacy_font_directory
+    _legacy_font_directory = Path(fonts_dir)
+
+
+def get_font_config():
+    if _legacy_font_directory is None:
+        return {}
+    return {
+        "font_directory": str(_legacy_font_directory),
+        "family": _legacy_font_face.family,
+        "regular": _legacy_font_face.regular,
+        "bold": _legacy_font_face.bold,
+        "italic": _legacy_font_face.italic,
+        "bold_italic": _legacy_font_face.bold_italic,
+    }
+
+
+def render_text_to_pdf_bytes(text, formatting_options=None):
+    if _legacy_font_directory is None:
+        raise RuntimeError("Fonts are not configured. Call set_font_files(...) first.")
+
+    renderer = MarkdownPdfRenderer(
+        font_directory=_legacy_font_directory,
+        font_face=_legacy_font_face,
+        formatting_options=formatting_options,
+    )
+    return renderer.render_to_bytes(text)

simpdf/renderer.py

@@ -0,0 +1,653 @@
+from __future__ import annotations
+
+from contextlib import contextmanager
+from pathlib import Path
+import re
+from typing import Mapping
+
+from fpdf import FPDF
+
+from .fonts import FontFace, coerce_font_face, register_font_family
+from .markdown import InlineFragment, create_markdown_parser, inline_fragments_from_node, parse_markdown_tree, table_rows_from_node
+from .options import merge_formatting_options
+
+
+class MarkdownPdfRenderer:
+    def __init__(
+        self,
+        font_directory: str | Path,
+        font_face: FontFace | Mapping[str, str],
+        formatting_options: dict | None = None,
+    ) -> None:
+        self.font_directory = Path(font_directory)
+        self.font_face = coerce_font_face(font_face)
+        self.options = merge_formatting_options(formatting_options)
+        self.parser = create_markdown_parser()
+
+    def render_to_bytes(self, markdown_text: str) -> bytes:
+        pdf = self._create_pdf()
+        font_family = register_font_family(pdf, self.font_directory, self.font_face)
+        self._render_tree(pdf, parse_markdown_tree(markdown_text, self.parser), font_family)
+        output = pdf.output()
+        if isinstance(output, str):
+            return output.encode("latin-1")
+        if isinstance(output, bytearray):
+            return bytes(output)
+        return output
+
+    def render_to_file(self, markdown_text: str, output_path: str | Path) -> Path:
+        destination = Path(output_path)
+        destination.parent.mkdir(parents=True, exist_ok=True)
+        destination.write_bytes(self.render_to_bytes(markdown_text))
+        return destination
+
+    def _create_pdf(self) -> FPDF:
+        page_options = self.options["page"]
+        margins = page_options["margins"]
+        pdf = FPDF(
+            orientation=page_options["orientation"],
+            format=page_options["format"],
+        )
+        pdf.set_margins(margins["left"], margins["top"], margins["right"])
+        pdf.set_auto_page_break(auto=True, margin=margins["bottom"])
+        pdf.add_page()
+        return pdf
+
+    def _render_tree(self, pdf: FPDF, tree, font_family: str) -> None:
+        for child in tree.children or []:
+            self._render_block(pdf, child, font_family, list_depth=0)
+
+    def _render_block(self, pdf: FPDF, node, font_family: str, *, list_depth: int) -> None:
+        if node.type == "heading":
+            self._render_heading(pdf, node, font_family)
+            return
+        if node.type == "paragraph":
+            self._render_paragraph(pdf, node, font_family)
+            return
+        if node.type in {"bullet_list", "ordered_list"}:
+            self._render_list(pdf, node, font_family, list_depth=list_depth)
+            return
+        if node.type == "blockquote":
+            self._render_blockquote(pdf, node, font_family, list_depth=list_depth)
+            return
+        if node.type == "table":
+            self._render_table(pdf, node, font_family)
+            return
+        if node.type == "fence":
+            self._render_code_block(pdf, node, font_family)
+            return
+        if node.type == "hr":
+            self._render_thematic_break(pdf)
+            return
+        for child in node.children or []:
+            self._render_block(pdf, child, font_family, list_depth=list_depth)
+
+    def _render_heading(self, pdf: FPDF, node, font_family: str) -> None:
+        level = min(6, max(1, int(node.tag[1:])))
+        heading_options = self.options["headings"]
+        if pdf.get_y() > pdf.t_margin:
+            pdf.ln(heading_options["spacing_before"].get(level, 1.5))
+        self._write_fragments(
+            pdf,
+            self._inline_fragments_for_first_child(node),
+            font_family=font_family,
+            font_size=heading_options["sizes"].get(level, 12),
+            line_height_multiplier=heading_options["line_height"],
+            force_bold=True,
+        )
+        pdf.ln(heading_options["spacing_after"].get(level, 2.0))
+
+    def _render_paragraph(self, pdf: FPDF, node, font_family: str) -> None:
+        fragments = self._inline_fragments_for_first_child(node)
+        if fragments:
+            self._write_fragments(
+                pdf,
+                fragments,
+                font_family=font_family,
+                font_size=self.options["text"]["font_size"],
+                line_height_multiplier=self.options["text"]["line_height"],
+            )
+        pdf.ln(self.options["paragraph"]["spacing_after"])
+
+    def _render_list(self, pdf: FPDF, node, font_family: str, *, list_depth: int) -> None:
+        list_options = self.options["lists"]
+        start = int(node.attrs.get("start", 1))
+        for index, item in enumerate(node.children or []):
+            prefix = f"{list_options['bullet']} " if node.type == "bullet_list" else f"{start + index}. "
+            self._render_list_item(pdf, item, font_family, prefix=prefix, list_depth=list_depth)
+        if node.children:
+            pdf.ln(list_options["block_spacing_after"])
+
+    def _render_list_item(self, pdf: FPDF, node, font_family: str, *, prefix: str, list_depth: int) -> None:
+        list_options = self.options["lists"]
+        base_left = pdf.l_margin
+        indent = list_options["indent"] * (list_depth + 1)
+        prefix_width = pdf.get_string_width(prefix) + 1.0
+        body_left = base_left + indent + prefix_width
+        child_blocks = list(node.children or [])
+
+        rendered_first = False
+        first_block = child_blocks[0] if child_blocks else None
+        if first_block and first_block.type == "paragraph":
+            self._write_fragments(
+                pdf,
+                [InlineFragment(prefix)] + self._inline_fragments_for_first_child(first_block),
+                font_family=font_family,
+                font_size=self.options["text"]["font_size"],
+                line_height_multiplier=self.options["text"]["line_height"],
+                left_margin=base_left + indent,
+                hanging_left=body_left,
+            )
+            pdf.ln(list_options["item_spacing_after"])
+            rendered_first = True
+
+        with self._temporary_margins(pdf, left=body_left, right=pdf.r_margin):
+            for child in child_blocks[1 if rendered_first else 0 :]:
+                if not rendered_first:
+                    self._write_fragments(
+                        pdf,
+                        [InlineFragment(prefix)],
+                        font_family=font_family,
+                        font_size=self.options["text"]["font_size"],
+                        line_height_multiplier=self.options["text"]["line_height"],
+                        left_margin=base_left + indent,
+                    )
+                    rendered_first = True
+                self._render_block(pdf, child, font_family, list_depth=list_depth + 1)
+
+    def _render_blockquote(self, pdf: FPDF, node, font_family: str, *, list_depth: int) -> None:
+        quote_options = self.options["blockquote"]
+        start_page = pdf.page_no()
+        start_y = pdf.get_y()
+        bar_x = pdf.l_margin
+        content_left = pdf.l_margin + quote_options["indent"]
+        pdf.set_text_color(*quote_options["text_color"])
+        with self._temporary_margins(pdf, left=content_left, right=pdf.r_margin):
+            for child in node.children or []:
+                self._render_block(pdf, child, font_family, list_depth=list_depth)
+        pdf.set_text_color(*self.options["text"]["color"])
+        end_y = pdf.get_y()
+        if pdf.page_no() == start_page and end_y > start_y:
+            pdf.set_draw_color(*quote_options["text_color"])
+            pdf.set_line_width(quote_options["bar_width"])
+            x = bar_x + (quote_options["bar_gap"] / 2.0)
+            pdf.line(x, start_y, x, end_y)
+            pdf.set_draw_color(0, 0, 0)
+        pdf.ln(quote_options["spacing_after"])
+
+    def _render_code_block(self, pdf: FPDF, node, font_family: str) -> None:
+        code_options = self.options["code_block"]
+        font_size = code_options["font_size"]
+        line_height = code_options["line_height"]
+        padding = code_options["padding"]
+        text = self._normalize_for_pdf(node.content.rstrip("\n"))
+
+        usable_width = pdf.w - pdf.l_margin - pdf.r_margin
+        lines = text.splitlines() or [""]
+        height = (len(lines) * line_height) + (2 * padding)
+        if pdf.get_y() + height > pdf.h - pdf.b_margin:
+            pdf.add_page()
+
+        start_x = pdf.l_margin
+        start_y = pdf.get_y()
+        pdf.set_fill_color(*code_options["background_color"])
+        pdf.rect(start_x, start_y, usable_width, height, style="F")
+        pdf.set_xy(start_x + padding, start_y + padding)
+        pdf.set_font(font_family, "", font_size)
+        pdf.set_text_color(*code_options["text_color"])
+        pdf.multi_cell(max(1.0, usable_width - (2 * padding)), line_height, text)
+        pdf.set_text_color(*self.options["text"]["color"])
+        pdf.set_x(pdf.l_margin)
+        pdf.ln(code_options["spacing_after"])
+
+    def _render_thematic_break(self, pdf: FPDF) -> None:
+        rule_options = self.options["thematic_break"]
+        pdf.ln(rule_options["spacing_before"])
+        y = pdf.get_y()
+        pdf.set_draw_color(*rule_options["color"])
+        pdf.set_line_width(rule_options["width"])
+        pdf.line(pdf.l_margin, y, pdf.w - pdf.r_margin, y)
+        pdf.set_draw_color(0, 0, 0)
+        pdf.ln(rule_options["spacing_after"])
+
+    def _render_table(self, pdf: FPDF, node, font_family: str) -> None:
+        header, body = table_rows_from_node(node)
+        if not header and not body:
+            return
+
+        table_options = self.options["table"]
+        col_count = max([len(header)] + [len(row) for row in body] + [1])
+        normalized_header = header + [""] * (col_count - len(header))
+        normalized_body = [row + [""] * (col_count - len(row)) for row in body]
+        usable_width = pdf.w - pdf.l_margin - pdf.r_margin
+
+        pdf.set_font(font_family, "", table_options["font_size"])
+        widths = self._compute_table_col_widths(pdf, [normalized_header] + normalized_body, usable_width, table_options["min_col_width"])
+        self._draw_table_header(pdf, font_family, normalized_header, widths)
+        pdf.set_font(font_family, "", table_options["font_size"])
+        for row in normalized_body:
+            expected_height = self._estimate_row_height(pdf, row, widths)
+            if pdf.get_y() + expected_height > pdf.h - pdf.b_margin:
+                pdf.add_page()
+                self._draw_table_header(pdf, font_family, normalized_header, widths)
+                pdf.set_font(font_family, "", table_options["font_size"])
+            self._draw_table_row(pdf, row, widths)
+
+        pdf.ln(table_options["spacing_after"])
+        pdf.set_x(pdf.l_margin)
+
+    def _draw_table_header(self, pdf: FPDF, font_family: str, header: list[str], widths: list[float]) -> None:
+        table_options = self.options["table"]
+        pdf.set_font(font_family, "B", table_options["heading_font_size"])
+        expected_height = self._estimate_row_height(pdf, header, widths)
+        if pdf.get_y() + expected_height > pdf.h - pdf.b_margin:
+            pdf.add_page()
+        self._draw_table_row(pdf, header, widths)
+
+    def _draw_table_row(self, pdf: FPDF, row: list[str], widths: list[float]) -> float:
+        table_options = self.options["table"]
+        line_height = table_options["line_height"]
+        cell_padding = table_options["cell_padding"]
+        x0 = pdf.l_margin
+        y0 = pdf.get_y()
+
+        wrapped_per_cell = []
+        max_lines = 1
+        for index, width in enumerate(widths):
+            text = row[index] if index < len(row) else ""
+            wrapped = self._wrap_cell_text(pdf, text, max(1.0, width - (2 * cell_padding)))
+            wrapped_per_cell.append(wrapped)
+            max_lines = max(max_lines, len(wrapped))
+
+        row_height = max_lines * line_height + (2 * cell_padding)
+        x = x0
+        for index, width in enumerate(widths):
+            pdf.rect(x, y0, width, row_height)
+            pdf.set_xy(x + cell_padding, y0 + cell_padding)
+            pdf.multi_cell(max(1.0, width - (2 * cell_padding)), line_height, "\n".join(wrapped_per_cell[index]))
+            x += width
+            pdf.set_xy(x, y0)
+
+        pdf.set_xy(x0, y0 + row_height)
+        return row_height
+
+    def _estimate_row_height(self, pdf: FPDF, row: list[str], widths: list[float]) -> float:
+        table_options = self.options["table"]
+        cell_padding = table_options["cell_padding"]
+        line_height = table_options["line_height"]
+        max_lines = 1
+        for index, width in enumerate(widths):
+            text = row[index] if index < len(row) else ""
+            lines = self._wrap_cell_text(pdf, text, max(1.0, width - (2 * cell_padding)))
+            max_lines = max(max_lines, len(lines))
+        return max_lines * line_height + (2 * cell_padding)
+
+    def _compute_table_col_widths(self, pdf: FPDF, rows: list[list[str]], usable_width: float, min_col_width: float) -> list[float]:
+        col_count = max((len(row) for row in rows), default=1)
+        weights = [self._column_score(pdf, rows, index) for index in range(col_count)]
+        total_weight = sum(weights) or 1.0
+        widths = [(weight / total_weight) * usable_width for weight in weights]
+        widths = [max(min_col_width, width) for width in widths]
+        width_sum = sum(widths)
+
+        if width_sum > usable_width:
+            overflow = width_sum - usable_width
+            shrinkable = [max(0.0, width - min_col_width) for width in widths]
+            shrink_total = sum(shrinkable)
+            if shrink_total > 0:
+                widths = [
+                    width - overflow * (shrinkable[index] / shrink_total)
+                    for index, width in enumerate(widths)
+                ]
+
+        final_sum = sum(widths)
+        if final_sum:
+            scale = usable_width / final_sum
+            widths = [width * scale for width in widths]
+        return widths
+
+    def _column_score(self, pdf: FPDF, rows: list[list[str]], col_index: int) -> float:
+        max_cell_width = 0.0
+        max_token_width = 0.0
+        for row in rows:
+            value = self._normalize_for_pdf(row[col_index] if col_index < len(row) else "")
+            if not value:
+                continue
+            max_cell_width = max(max_cell_width, pdf.get_string_width(value))
+            for token in value.split():
+                max_token_width = max(max_token_width, pdf.get_string_width(token))
+        return max(1.0, (max_cell_width * 0.25) + (max_token_width * 0.75))
+
+    def _wrap_cell_text(self, pdf: FPDF, text: str, max_width: float) -> list[str]:
+        value = self._normalize_for_pdf(text)
+        if not value:
+            return [""]
+
+        lines: list[str] = []
+        for paragraph in value.splitlines():
+            if not paragraph.strip():
+                lines.append("")
+                continue
+
+            words = paragraph.split()
+            current = ""
+            for word in words:
+                trial = word if not current else f"{current} {word}"
+                if pdf.get_string_width(trial) <= max_width:
+                    current = trial
+                    continue
+
+                if current:
+                    lines.append(current)
+                    current = ""
+
+                if pdf.get_string_width(word) <= max_width:
+                    current = word
+                    continue
+
+                chunk = ""
+                for character in word:
+                    trial_chunk = chunk + character
+                    if pdf.get_string_width(trial_chunk) <= max_width:
+                        chunk = trial_chunk
+                    else:
+                        if chunk:
+                            lines.append(chunk)
+                        chunk = character
+                current = chunk
+
+            if current:
+                lines.append(current)
+
+        return lines or [""]
+
+    def _write_fragments(
+        self,
+        pdf: FPDF,
+        fragments: list[InlineFragment],
+        *,
+        font_family: str,
+        font_size: float,
+        line_height_multiplier: float,
+        left_margin: float | None = None,
+        hanging_left: float | None = None,
+        force_bold: bool = False,
+    ) -> None:
+        line_height = round(font_size * line_height_multiplier / 2.5, 2)
+        current_left = left_margin if left_margin is not None else pdf.l_margin
+        current_hanging = hanging_left if hanging_left is not None else current_left
+        lines = self._layout_fragments_to_lines(
+            pdf,
+            fragments,
+            font_family=font_family,
+            font_size=font_size,
+            first_left=current_left,
+            rest_left=current_hanging,
+            force_bold=force_bold,
+        )
+
+        for index, line in enumerate(lines):
+            line_left = current_left if index == 0 else current_hanging
+            self._ensure_space_for_line(pdf, line_height)
+            pdf.set_xy(line_left, pdf.get_y())
+            current_x = line_left
+            for fragment in line:
+                text = fragment.text
+                if not text:
+                    continue
+                style = self._fragment_style(fragment, force_bold=force_bold)
+                text_color = self._fragment_text_color(fragment)
+                pdf.set_font(font_family, style, font_size)
+                pdf.set_text_color(*text_color)
+                width = pdf.get_string_width(text)
+                pdf.set_xy(current_x, pdf.get_y())
+                pdf.cell(width, line_height, text, link=fragment.link or "")
+                current_x += width
+            pdf.set_xy(line_left, pdf.get_y() + line_height)
+        pdf.set_text_color(*self.options["text"]["color"])
+
+    def _layout_fragments_to_lines(
+        self,
+        pdf: FPDF,
+        fragments: list[InlineFragment],
+        *,
+        font_family: str,
+        font_size: float,
+        first_left: float,
+        rest_left: float,
+        force_bold: bool,
+    ) -> list[list[InlineFragment]]:
+        lines: list[list[InlineFragment]] = []
+        current_line: list[InlineFragment] = []
+        current_width = 0.0
+        line_index = 0
+
+        def line_left() -> float:
+            return first_left if line_index == 0 else rest_left
+
+        def available_width() -> float:
+            return max(1.0, pdf.w - pdf.r_margin - line_left())
+
+        def flush_line() -> None:
+            nonlocal current_line, current_width, line_index
+            trimmed = self._trim_trailing_whitespace(current_line)
+            lines.append(trimmed)
+            current_line = []
+            current_width = 0.0
+            line_index += 1
+
+        for fragment in fragments:
+            normalized_text = self._normalize_for_pdf(fragment.text)
+            if not normalized_text:
+                continue
+
+            pieces = normalized_text.split("\n")
+            for piece_index, piece in enumerate(pieces):
+                if piece:
+                    for token in self._split_fragment_tokens(fragment, piece):
+                        token = self._drop_leading_whitespace_if_needed(token, current_width)
+                        if not token.text:
+                            continue
+
+                        token_width = self._fragment_width(pdf, token, font_family, font_size, force_bold=force_bold)
+                        if current_width + token_width <= available_width():
+                            current_line.append(token)
+                            current_width += token_width
+                            continue
+
+                        if current_line:
+                            flush_line()
+                            token = self._drop_leading_whitespace_if_needed(token, current_width)
+                            if not token.text:
+                                continue
+                            token_width = self._fragment_width(pdf, token, font_family, font_size, force_bold=force_bold)
+
+                        if token_width <= available_width():
+                            current_line.append(token)
+                            current_width += token_width
+                            continue
+
+                        for chunk in self._split_fragment_to_fit(
+                            pdf,
+                            token,
+                            font_family=font_family,
+                            font_size=font_size,
+                            max_width=available_width(),
+                            force_bold=force_bold,
+                        ):
+                            chunk = self._drop_leading_whitespace_if_needed(chunk, current_width)
+                            if not chunk.text:
+                                continue
+                            chunk_width = self._fragment_width(pdf, chunk, font_family, font_size, force_bold=force_bold)
+                            if current_width and current_width + chunk_width > available_width():
+                                flush_line()
+                                chunk = self._drop_leading_whitespace_if_needed(chunk, current_width)
+                                if not chunk.text:
+                                    continue
+                                chunk_width = self._fragment_width(pdf, chunk, font_family, font_size, force_bold=force_bold)
+                            current_line.append(chunk)
+                            current_width += chunk_width
+
+                if piece_index < len(pieces) - 1:
+                    flush_line()
+
+        if current_line or not lines:
+            lines.append(self._trim_trailing_whitespace(current_line))
+        return lines
+
+    def _split_fragment_tokens(self, fragment: InlineFragment, text: str) -> list[InlineFragment]:
+        tokens = re.findall(r"\S+\s*|\s+", text)
+        return [self._fragment_with_text(fragment, token) for token in tokens]
+
+    def _split_fragment_to_fit(
+        self,
+        pdf: FPDF,
+        fragment: InlineFragment,
+        *,
+        font_family: str,
+        font_size: float,
+        max_width: float,
+        force_bold: bool,
+    ) -> list[InlineFragment]:
+        chunks: list[InlineFragment] = []
+        current = ""
+        for character in fragment.text:
+            trial = current + character
+            if current and self._fragment_width(
+                pdf,
+                self._fragment_with_text(fragment, trial),
+                font_family,
+                font_size,
+                force_bold=force_bold,
+            ) > max_width:
+                chunks.append(self._fragment_with_text(fragment, current))
+                current = character
+            else:
+                current = trial
+        if current:
+            chunks.append(self._fragment_with_text(fragment, current))
+        return chunks or [fragment]
+
+    def _fragment_width(
+        self,
+        pdf: FPDF,
+        fragment: InlineFragment,
+        font_family: str,
+        font_size: float,
+        *,
+        force_bold: bool,
+    ) -> float:
+        pdf.set_font(font_family, self._fragment_style(fragment, force_bold=force_bold), font_size)
+        return pdf.get_string_width(fragment.text)
+
+    def _fragment_style(self, fragment: InlineFragment, *, force_bold: bool) -> str:
+        style_parts = []
+        if force_bold or fragment.bold:
+            style_parts.append("B")
+        if fragment.italic:
+            style_parts.append("I")
+        if fragment.link and self.options["links"]["underline"]:
+            style_parts.append("U")
+        return "".join(style_parts)
+
+    def _fragment_text_color(self, fragment: InlineFragment) -> tuple[int, int, int]:
+        if fragment.link:
+            return self.options["links"]["color"]
+        if fragment.code:
+            return self.options["inline_code"]["text_color"]
+        return self.options["text"]["color"]
+
+    def _trim_trailing_whitespace(self, fragments: list[InlineFragment]) -> list[InlineFragment]:
+        if not fragments:
+            return []
+        trimmed = list(fragments)
+        while trimmed and not trimmed[-1].text.strip():
+            trimmed.pop()
+        if trimmed and trimmed[-1].text != trimmed[-1].text.rstrip():
+            trimmed[-1] = self._fragment_with_text(trimmed[-1], trimmed[-1].text.rstrip())
+        return trimmed
+
+    def _drop_leading_whitespace_if_needed(self, fragment: InlineFragment, current_width: float) -> InlineFragment:
+        if current_width > 0:
+            return fragment
+        stripped = fragment.text.lstrip()
+        if stripped == fragment.text:
+            return fragment
+        return self._fragment_with_text(fragment, stripped)
+
+    def _fragment_with_text(self, fragment: InlineFragment, text: str) -> InlineFragment:
+        return InlineFragment(
+            text=text,
+            bold=fragment.bold,
+            italic=fragment.italic,
+            code=fragment.code,
+            link=fragment.link,
+        )
+
+    def _ensure_space_for_line(self, pdf: FPDF, line_height: float) -> None:
+        if pdf.get_y() + line_height <= pdf.h - pdf.b_margin:
+            return
+        pdf.add_page()
+
+    def _inline_fragments_for_first_child(self, node) -> list[InlineFragment]:
+        if not node.children:
+            return []
+        return inline_fragments_from_node(node.children[0])
+
+    @contextmanager
+    def _temporary_margins(self, pdf: FPDF, *, left: float, right: float):
+        previous_left = pdf.l_margin
+        previous_right = pdf.r_margin
+        previous_x = pdf.get_x()
+        pdf.set_left_margin(left)
+        pdf.set_right_margin(right)
+        if pdf.get_x() < left:
+            pdf.set_x(left)
+        try:
+            yield
+        finally:
+            pdf.set_left_margin(previous_left)
+            pdf.set_right_margin(previous_right)
+            pdf.set_x(max(previous_left, previous_x))
+
+    @staticmethod
+    def _normalize_for_pdf(text: str | None) -> str:
+        if text is None:
+            return ""
+        return (
+            text.replace("\u00A0", " ")
+            .replace("\u202F", " ")
+            .replace("\u2011", "-")
+            .replace("\u00AD", "")
+        )
+
+
+def render_markdown_to_pdf_bytes(
+    markdown_text: str,
+    *,
+    font_directory: str | Path,
+    font_face: FontFace | Mapping[str, str],
+    formatting_options: dict | None = None,
+) -> bytes:
+    renderer = MarkdownPdfRenderer(
+        font_directory=font_directory,
+        font_face=font_face,
+        formatting_options=formatting_options,
+    )
+    return renderer.render_to_bytes(markdown_text)
+
+
+def render_markdown_to_pdf_file(
+    markdown_text: str,
+    output_path: str | Path,
+    *,
+    font_directory: str | Path,
+    font_face: FontFace | Mapping[str, str],
+    formatting_options: dict | None = None,
+) -> Path:
+    renderer = MarkdownPdfRenderer(
+        font_directory=font_directory,
+        font_face=font_face,
+        formatting_options=formatting_options,
+    )
+    return renderer.render_to_file(markdown_text, output_path)

simpdf-0.1.0.dist-info/METADATA

@@ -0,0 +1,211 @@
+Metadata-Version: 2.4
+Name: simpdf
+Version: 0.1.0
+Summary: Markdown-to-PDF rendering with FPDF2 and configurable TTF fonts.
+Author: Dmitry
+Keywords: markdown,pdf,fpdf,cyrillic
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: fpdf2<3,>=2.8.0
+Requires-Dist: markdown-it-py<4,>=3.0.0
+Provides-Extra: dev
+Requires-Dist: pytest<9,>=8.0.0; extra == "dev"
+
+# simpdf
+
+`simpdf` is a small Python library for rendering Markdown into PDF with `fpdf2`, while keeping font handling explicit so Cyrillic and other non-Latin text work reliably with external TTF fonts.
+
+The library is centered on a `MarkdownPdfRenderer` class. You give it a directory with TTF files, describe the font face to register, and then render Markdown into PDF bytes or directly into a file.
+
+## Features
+
+- Uses `fpdf2` as the PDF backend
+- Supports external TTF fonts and Cyrillic-friendly fonts such as DejaVu Sans
+- Provides a helper to download DejaVu Sans fonts into a target directory
+- Class-first API with optional convenience helpers
+- Minimal CLI for rendering Markdown and downloading DejaVu fonts
+- Supports these Markdown elements in v1:
+  - headings
+  - paragraphs
+  - bold and italic text
+  - inline code
+  - ordered and unordered lists
+  - tables
+  - blockquotes
+  - fenced code blocks
+  - thematic breaks
+  - clickable links
+
+## Installation
+
+```bash
+pip install simpdf
+```
+
+For development and tests:
+
+```bash
+pip install -e .[dev]
+```
+
+## Quick Start
+
+```python
+from simpdf import FontFace, MarkdownPdfRenderer
+
+renderer = MarkdownPdfRenderer(
+    font_directory="fonts",
+    font_face=FontFace.dejavu_sans(),
+)
+
+markdown_text = """
+# Example
+
+Привет, мир.
+
+- one
+- two
+"""
+
+pdf_bytes = renderer.render_to_bytes(markdown_text)
+
+with open("output.pdf", "wb") as handle:
+    handle.write(pdf_bytes)
+```
+
+## Downloading DejaVu Fonts
+
+The library does not bundle fonts inside the wheel. Use the download helper to populate your own font directory.
+
+```python
+from simpdf import download_dejavu_fonts
+
+downloaded = download_dejavu_fonts("fonts")
+print([path.name for path in downloaded])
+```
+
+The helper downloads the DejaVu font files from this public GitHub repository layout:
+
+- `https://github.com/shwars/simpdf/raw/refs/heads/main/fonts/DejaVuSans.ttf`
+- other font files use the same URL pattern
+
+## Using Custom Fonts
+
+You can use any TTF family as long as you provide at least a regular face. Bold, italic, and bold-italic are optional; if omitted, the regular face is reused.
+
+```python
+from simpdf import FontFace, MarkdownPdfRenderer
+
+renderer = MarkdownPdfRenderer(
+    font_directory="my-fonts",
+    font_face=FontFace(
+        family="NotoSansCustom",
+        regular="NotoSans-Regular.ttf",
+        bold="NotoSans-Bold.ttf",
+        italic="NotoSans-Italic.ttf",
+        bold_italic="NotoSans-BoldItalic.ttf",
+    ),
+)
+```
+
+Font file values may be file names relative to `font_directory` or absolute paths.
+
+## Formatting Options
+
+Formatting is configured with a plain nested dictionary. Any omitted value falls back to the library defaults.
+
+Example:
+
+```python
+from simpdf import FontFace, MarkdownPdfRenderer
+
+renderer = MarkdownPdfRenderer(
+    font_directory="fonts",
+    font_face=FontFace.dejavu_sans(),
+    formatting_options={
+        "text": {"font_size": 11},
+        "headings": {
+            "sizes": {1: 26, 2: 20, 3: 16},
+        },
+        "lists": {"indent": 9},
+        "table": {"heading_font_size": 13},
+    },
+)
+```
+
+Supported option groups:
+
+- `page`: page size, orientation, and margins
+- `text`: base font size, line height multiplier, text color
+- `headings`: per-level sizes and spacing
+- `paragraph`: paragraph spacing
+- `lists`: indent, bullet symbol, list spacing
+- `blockquote`: indent, bar styling, text color
+- `table`: font sizes, padding, minimum column width, spacing
+- `code_block`: font size, padding, colors, spacing
+- `inline_code`: inline code text color
+- `links`: link color and underline toggle
+- `thematic_break`: rule color, width, spacing
+
+## Convenience Helpers
+
+If you prefer a functional call site, `simpdf` also exports:
+
+- `render_markdown_to_pdf_bytes(...)`
+- `render_markdown_to_pdf_file(...)`
+
+These helpers internally construct `MarkdownPdfRenderer`.
+
+## CLI Usage
+
+Render Markdown into PDF:
+
+```bash
+simpdf render input.md output.pdf \
+  --fonts-dir ./fonts \
+  --family-name DejaVuSans \
+  --font-regular DejaVuSans.ttf \
+  --font-bold DejaVuSans-Bold.ttf \
+  --font-italic DejaVuSans-Oblique.ttf \
+  --font-bold-italic DejaVuSans-BoldOblique.ttf
+```
+
+Download DejaVu fonts:
+
+```bash
+simpdf download-dejavu ./fonts
+```
+
+If you want custom formatting from the CLI, pass a JSON file with `--options-file`.
+
+## Examples
+
+See [`examples/basic_render.py`](/D:/GIT/simpdf/examples/basic_render.py), [`examples/custom_font_and_style.py`](/D:/GIT/simpdf/examples/custom_font_and_style.py), and [`examples/rich_markdown.py`](/D:/GIT/simpdf/examples/rich_markdown.py).
+
+## Tests
+
+The repo now contains a pytest suite that covers:
+
+- font config validation
+- DejaVu download helper behavior
+- markdown token flattening and table extraction
+- PDF rendering with Cyrillic content
+- formatting overrides
+- CLI render and download flows
+
+Run tests with:
+
+```bash
+pytest
+```
+
+## Compatibility Note
+
+For older code that imported `simpdf.pdfgen`, a small compatibility wrapper is still present. The recommended API is the class-based renderer from `simpdf`.

simpdf-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+simpdf/__init__.py,sha256=5JvaXzFEiLCR3VBBM7Zuu0N3XJ9nuDpmb9-WgMvzjiI,354
+simpdf/__main__.py,sha256=PSQ4rpL0dG6f-qH4N7H-gD9igQkdHzH4yVZDcW8lfZo,80
+simpdf/cli.py,sha256=nDgAIXdwJMFhpbwhj1WLeMijDt1embsXyrHOzaUBYP4,2211
+simpdf/fonts.py,sha256=2BneyRsrPXhau60AZ9mz1vXbKGcl2SmFKAAqORaBn3M,3832
+simpdf/markdown.py,sha256=fPdHOD0LvVRE4EdjSClyODxHsxnxY1fiZ7E5RzNqbgc,2820
+simpdf/options.py,sha256=M9ayPK-D1qjn01CdpIHQ6roYEL5EUloZy0NOHxBijI0,2975
+simpdf/pdfgen.py,sha256=e0rImxgYsv1gsv_jdA0nbjUjDW_1b_6OHQc_bQkGMJI,1121
+simpdf/renderer.py,sha256=uPx7TI7fojcGFx576WVvRBmZhRGYu_sbPoSIYShk7zg,26954
+simpdf-0.1.0.dist-info/METADATA,sha256=TvBnCRoWmtBSV_7xdysG_ltw6PuiDASFu2CkA9ryB3g,5977
+simpdf-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+simpdf-0.1.0.dist-info/entry_points.txt,sha256=M7yPEHw9qsc0L_i2WZiArLaUgyzzQofNNqFRJ6f_iIc,43
+simpdf-0.1.0.dist-info/top_level.txt,sha256=FNWhCQN_0gcVN0M2P3YDYhbFcVLWznmY5ESEy-c_8P4,7
+simpdf-0.1.0.dist-info/RECORD,,

simpdf-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

simpdf-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+simpdf = simpdf.cli:main

simpdf-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+simpdf