القائمة
Converting Markdown to professional PDFs using Pandoc, WeasyPrint, ReportLab, and related tools
يُحدَّد Prompt الذي يراجع المصدر أولًا بشكل افتراضي. يمكنك التبديل إلى أمر مباشر أو تنزيل نسخة محلية.
اقرأ SKILL.md وأي ملفات مرافقة يعرضها SkillsMP قبل أن تقرر التثبيت.
التثبيت باستخدام Codex أو Claude انسخ هذا Prompt والصقه في Codex أو Claude أو مساعد آخر ليراجع صفحة Skill ويثبّتها لك.
يتجاوز الأمر المباشر Prompt المخصّص للمراجعة. افحص المصدر قبل تشغيله.
npx skills add https://github.com/cosmicstack-labs/mercury-agent-skills --skill markdown-to-pdfيبقى الأمر في سطر واحد. مرّر أفقيًا لمراجعته كاملًا قبل النسخ.
تفضّل نسخة محلية؟ نزّل الملفات المتاحة حاليًا لدى SkillsMP.
استنادا إلى تصنيف SOC المهني
عرض SKILL.md
| name | markdown-to-pdf |
| description | Converting Markdown to professional PDFs using Pandoc, WeasyPrint, ReportLab, and related tools |
| metadata | {"author":"cosmicstack-labs","version":"1.0.0","category":"pdf-generation","tags":["markdown","pdf","pandoc","weasyprint","reportlab","conversion"]} |
Convert Markdown documents into polished, production-ready PDFs. This skill covers the major toolchains — Pandoc, WeasyPrint, ReportLab — plus CSS print styling, template systems, and batch conversion workflows.
| Tool | Approach | Best For | Output Quality |
|---|---|---|---|
| Pandoc | Markdown → PDF via LaTeX/Context/Wkhtmltopdf | Books, papers, reports | High |
| WeasyPrint | Markdown → HTML → PDF via CSS print | Web-like documents, branded PDFs | High |
| ReportLab | Programmatic PDF generation via Python | Dynamic, data-driven PDFs | Very High |
| md-to-pdf | Node.js CLI for quick markdown → PDF | Simple documents, quick output | Medium |
| Puppeteer/Playwright | Markdown → HTML → Headless browser → PDF | Pixel-perfect web-to-PDF | Very High |
Pandoc is the Swiss Army knife of document conversion. It reads Markdown and outputs PDF via an intermediate engine (default: LaTeX).
# Simple markdown to PDF (uses pdflatex)
pandoc input.md -o output.pdf
# With metadata file
pandoc input.md --metadata-file=metadata.yaml -o output.pdf
# Specify output engine
pandoc input.md --pdf-engine=xelatex -o output.pdf
# Using wkhtmltopdf instead of LaTeX
pandoc input.md --pdf-engine=wkhtmltopdf -o output.pdf
# Custom LaTeX template
pandoc input.md \
--template=custom-template.tex \
--pdf-engine=xelatex \
--toc \
--number-sections \
-o output.pdf
# With bibliography
pandoc input.md \
--bibliography=references.bib \
--csl=ieee.csl \
--citeproc \
-o output.pdf
# Custom font and margins
pandoc input.md \
-V geometry:"top=2cm, bottom=2cm, left=2.5cm, right=2.5cm" \
-V mainfont="Times New Roman" \
-V fontsize=12pt \
-o output.pdf
# metadata.yaml
---
title: "Technical Report on Distributed Systems"
author:
- "Jane Doe"
- "John Smith"
date: "2025-01-15"
subtitle: "Performance Analysis of Event-Driven Architectures"
abstract: |
This report analyzes the performance characteristics of event-driven
architectures in distributed systems, comparing Apache Kafka, RabbitMQ,
and AWS SQS across latency, throughput, and fault tolerance metrics.
keywords: [distributed-systems, event-driven, kafka, rabbitmq, performance]
lang: en-US
geometry:
- top=25mm
- bottom=25mm
- left=30mm
- right=25mm
fontsize: 11pt
mainfont: "DejaVu Serif"
monofont: "DejaVu Sans Mono"
toc: true
toc-depth: 3
numbersections: true
linestretch: 1.5
---
#!/usr/bin/env python3
"""Pandoc filter to add custom styling to code blocks."""
import pandocfilters as pf
def code_blocks(key, value, format, meta):
"""Wrap code blocks in a styled container."""
if key == 'CodeBlock':
[[ident, classes, keyvals], code] = value
if 'python' in classes:
# Add a custom div wrapper for Python code
return pf.Div(
([ident, ['python-block'], keyvals],
[pf.CodeBlock([ident, classes, keyvals], code)])
)
if __name__ == '__main__':
pf.toJSONFilter(code_blocks)
# Use the filter
pandoc input.md --filter=./code_styler.py -o output.pdf
WeasyPrint renders HTML with CSS print styles into PDFs. It's ideal for documents that need pixel-perfect branding, colors, and web-like layouts.
"""Convert HTML to PDF using WeasyPrint."""
from weasyprint import HTML
# Basic conversion
HTML('document.html').write_pdf('output.pdf')
# From a URL
HTML('https://example.com/report').write_pdf('webpage.pdf')
# From a string
html_content = """
<html>
<body>
<h1>Hello World</h1>
<p>This is a PDF generated from an HTML string.</p>
</body>
</html>
"""
HTML(string=html_content).write_pdf('from_string.pdf')
"""Full pipeline: Markdown to HTML to PDF with CSS styling."""
import markdown
from weasyprint import HTML
def markdown_to_pdf(md_path, css_path, output_path):
"""Convert markdown to PDF through HTML intermediate."""
with open(md_path, 'r') as f:
md_content = f.read()
# Convert markdown to HTML
html_content = markdown.markdown(
md_content,
extensions=['tables', 'fenced_code', 'codehilite',
'toc', 'sane_lists', 'attr_list']
)
# Wrap in full HTML document
full_html = f"""
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<link rel="stylesheet" href="{css_path}">
</head>
<body>
{html_content}
</body>
</html>
"""
# Generate PDF
HTML(string=full_html).write_pdf(output_path)
print(f"PDF generated: {output_path}")
# Usage
markdown_to_pdf('report.md', 'print.css', 'report.pdf')
/* print.css — Professional print stylesheet for PDF generation */
/* Page setup */
@page {
size: A4;
margin: 2.5cm 2cm 2.5cm 2cm;
@top-center {
content: element(pageHeader);
font-size: 9pt;
color: #666;
}
@bottom-center {
content: counter(page) " / " counter(pages);
font-size: 9pt;
color: #666;
}
@bottom-left {
content: "Confidential";
font-size: 8pt;
color: #999;
font-style: italic;
}
}
/* First page — no header, different margins */
@page:first {
margin-top: 4cm;
@top-center {
content: none;
}
}
/* Section start — reset page counter */
@page chapter {
@top-center {
content: "Chapter " counter(chapter);
}
}
/* Base typography */
body {
font-family: "DejaVu Serif", Georgia, "Times New Roman", serif;
: ;
: ;
: ;
: h2 h3 figure table;
}
{
: ;
: bold;
: ;
: always;
: avoid;
: ;
: solid ;
: ;
}
{
: avoid;
}
{
: ;
: bold;
: ;
: avoid;
: ;
: h2;
}
{
: (h2) ;
}
{
: ;
: bold;
: ;
: avoid;
: ;
: h3;
}
{
: (h2) (h3) ;
}
{
: justify;
: ;
: ;
}
pre {
: , , monospace;
: ;
: ;
: solid ;
: solid ;
: ;
: avoid;
: pre-wrap;
: break-word;
}
{
: , , monospace;
: ;
: ;
: ;
: ;
}
pre {
: none;
: ;
}
{
: ;
: collapse;
: ;
: ;
: auto;
}
{
: table-header-group;
}
{
: avoid;
: auto;
}
{
: ;
: white;
: bold;
: ;
: left;
}
{
: ;
: solid ;
}
(even) {
: ;
}
{
: ;
: auto;
: avoid;
}
{
: ;
: center;
: avoid;
}
{
: ;
: italic;
: ;
: ;
}
{
: ;
: none;
}
, {
: ;
: ;
}
{
: ;
}
{
: solid ;
: ;
: ;
: ;
: italic;
}
{
: always;
: center;
: ;
}
{
: ;
: none;
: ;
}
{
: ;
: ;
: ;
}
{
: ;
: ;
}
{
: ;
: ;
: ;
}
{
: always;
}
{
: none;
: ;
}
{
: none;
: ;
}
{
: ;
: dotted ;
}
{
: ;
: none;
}
{
: bold;
: ;
}
{
: ;
: ;
}
ReportLab gives you complete control over PDF layout programmatically from Python.
"""Create a basic PDF with ReportLab."""
from reportlab.lib.pagesizes import A4
from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
from reportlab.lib.units import cm, mm
from reportlab.lib import colors
from reportlab.platypus import (
SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle,
Image, PageBreak, ListFlowable, ListItem
)
from reportlab.lib.enums import TA_CENTER, TA_JUSTIFY
def create_report(output_path):
"""Generate a professional report PDF."""
doc = SimpleDocTemplate(
output_path,
pagesize=A4,
rightMargin=2*cm,
leftMargin=2*cm,
topMargin=2*cm,
bottomMargin=2*cm,
title="Annual Report 2025",
author="Data Analytics Team",
)
styles = getSampleStyleSheet()
story = []
# Title page
title_style = ParagraphStyle(
'CustomTitle',
parent=styles['Title'],
fontSize=28,
leading=34,
spaceAfter=20,
alignment=TA_CENTER,
textColor=colors.HexColor('#1a1a2e'),
)
story.append(Spacer(1, 5*cm))
story.append(Paragraph("Annual Report 2025", title_style))
story.append(Spacer(1, 1*cm))
subtitle_style = ParagraphStyle(
'Subtitle',
parent=styles['Normal'],
fontSize=16,
alignment=TA_CENTER,
textColor=colors.HexColor(),
)
story.append(Paragraph(, subtitle_style))
story.append(Spacer(, *cm))
story.append(Paragraph(, subtitle_style))
story.append(PageBreak())
toc_heading = ParagraphStyle(
,
parent=styles[],
fontSize=,
spaceAfter=,
)
story.append(Paragraph(, toc_heading))
story.append(Spacer(, *cm))
toc_items = [
,
,
,
,
,
,
]
item toc_items:
story.append(Paragraph(item, styles[]))
story.append(Spacer(, *cm))
story.append(PageBreak())
story.append(Paragraph(, styles[]))
story.append(Spacer(, *cm))
body_style = ParagraphStyle(
,
parent=styles[],
alignment=TA_JUSTIFY,
spaceAfter=,
fontSize=,
leading=,
)
story.append(Paragraph(
,
body_style
))
story.append(Spacer(, *cm))
story.append(Paragraph(, styles[]))
data = [
[, , , , ],
[, , , , ],
[, , , , ],
[, , , , ],
[, , , , ],
]
table = Table(data, colWidths=[*cm, *cm, *cm, *cm, *cm])
table.setStyle(TableStyle([
(, (, ), (-, ), colors.HexColor()),
(, (, ), (-, ), colors.white),
(, (, ), (-, -), ),
(, (, ), (-, ), ),
(, (, ), (-, ), ),
(, (, ), (-, -), ),
(, (, ), (-, ), ),
(, (, ), (-, ), ),
(, (, ), (-, -), colors.HexColor()),
(, (, ), (-, -), [colors.HexColor(), colors.white]),
(, (, ), (-, -), , colors.HexColor()),
(, (, ), (-, -), , colors.HexColor()),
]))
story.append(table)
doc.build(story)
()
__name__ == :
create_report()
"""ReportLab document with headers, footers, and page templates."""
from reportlab.lib.pagesizes import A4
from reportlab.lib.units import cm
from reportlab.lib import colors
from reportlab.platypus import (
SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle,
PageBreak, Frame, PageTemplate, BaseDocTemplate
)
from reportlab.lib.styles import getSampleStyleSheet
from reportlab.pdfgen import canvas
class NumberedCanvas(canvas.Canvas):
"""Canvas that adds page numbers and headers."""
def __init__(self, *args, **kwargs):
canvas.Canvas.__init__(self, *args, **kwargs)
self._saved_page_states = []
def showPage(self):
self._saved_page_states.append(dict(self.__dict__))
canvas.Canvas.showPage(self)
def save(self):
num_pages = len(self._saved_page_states)
for state in self._saved_page_states:
self.__dict__.update(state)
self.draw_header_footer(num_pages)
canvas.Canvas.showPage(self)
canvas.Canvas.save(self)
def ():
.setFont(, )
.setFillColor(colors.HexColor())
.drawString(*cm, A4[] - *cm, )
.drawRightString(A4[] - *cm, A4[] - *cm, )
.setStrokeColor(colors.HexColor())
.setLineWidth()
.line(*cm, A4[] - *cm, A4[] - *cm, A4[] - *cm)
.setFont(, )
.drawCentredString(
A4[] / , *cm,
)
.line(*cm, *cm, A4[] - *cm, *cm)
():
doc = SimpleDocTemplate(
output_path,
pagesize=A4,
leftMargin=*cm,
rightMargin=*cm,
topMargin=*cm,
bottomMargin=*cm,
)
styles = getSampleStyleSheet()
story = []
story.append(Paragraph(, styles[]))
story.append(Spacer(, *cm))
story.append(Paragraph(
,
styles[]
))
story.append(PageBreak())
story.append(Paragraph(, styles[]))
story.append(Paragraph(
,
styles[]
))
doc.build(story, canvasmaker=NumberedCanvas)
# Pandoc supports highlighting via LaTeX packages
pandoc code_doc.md \
--highlight-style=pygments \
--pdf-engine=xelatex \
-V monofont="DejaVu Sans Mono" \
-o highlighted.pdf
# List available highlight styles
pandoc --list-highlight-styles
# Available styles: pygments, tango, espresso, zenburn, haddock, breezedark, kate, monochrome, etc.
# Use a custom theme file
pandoc input.md --highlight-style=my.theme -o output.pdf
"""Add syntax highlighting to HTML before PDF conversion."""
import markdown
from pygments import highlight
from pygments.lexers import get_lexer_by_name
from pygments.formatters import HtmlFormatter
from weasyprint import HTML
def markdown_with_highlighting(md_path, output_path):
"""Convert Markdown to PDF with code syntax highlighting."""
with open(md_path, 'r') as f:
md_content = f.read()
# Custom extension for code highlighting
def highlight_code(source, lang, class_name, options, md):
"""Pygments-based code highlighter."""
if not lang:
return f'<pre><code>{source}</code></pre>'
try:
lexer = get_lexer_by_name(lang, stripall=True)
formatter = HtmlFormatter(
style='monokai',
linenos=True,
cssclass='codehilite'
)
return highlight(source, lexer, formatter)
except:
return f'<pre><code class="language-{lang}">{source}</code></pre>'
# Register the extension
md = markdown.Markdown(
extensions=['fenced_code', 'codehilite', 'tables', ],
extension_configs={
: {
: ,
}
}
)
html_content = md.convert(md_content)
css = HtmlFormatter(style=).get_style_defs()
full_html =
HTML(string=full_html).write_pdf(output_path)
markdown_with_highlighting(, )
# Automatic TOC generation
pandoc input.md --toc --toc-depth=3 -o output.pdf
# Custom TOC title
pandoc input.md --toc -V toc-title="Contents" -o output.pdf
"""Generate a table of contents using BeautifulSoup."""
from bs4 import BeautifulSoup
import markdown
from weasyprint import HTML
def generate_toc(md_path, output_path):
"""Generate a PDF with an auto-generated table of contents."""
with open(md_path, 'r') as f:
md_content = f.read()
# Convert to HTML
md = markdown.Markdown(extensions=['tables', 'fenced_code', 'toc'])
html = md.convert(md_content)
soup = BeautifulSoup(html, 'html.parser')
# Extract headings for TOC
toc_items = []
for heading in soup.find_all(['h1', 'h2', 'h3']):
level = int(heading.name[1])
text = heading.get_text()
anchor = heading.get('id', text.lower().replace(' ', '-'))
toc_items.append((level, text, anchor))
# Build TOC HTML
toc_html = '<div class="toc">\n<h1>Table of Contents</h1>\n<ul>\n'
for level, text, anchor in toc_items:
indent = ' ' * (level - 1)
toc_html += f'{indent}<li class="toc-h{level}"><a href="#{anchor}">{text}</a></li>\n'
toc_html += '</ul>\n</div>\n'
# Prepend TOC to document
full_html =
HTML(string=full_html).write_pdf(output_path)
# CJK (Chinese, Japanese, Korean) support requires xelatex or lualatex
# Install CJK fonts
pandoc cjk_document.md \
--pdf-engine=xelatex \
-V CJKmainfont="Noto Sans CJK SC" \
-V mainfont="Noto Sans" \
-o cjk_output.pdf
# With specified font for each script
pandoc mixed_document.md \
--pdf-engine=xelatex \
-V mainfont="DejaVu Serif" \
-V CJKmainfont="Noto Sans CJK SC" \
-o multilingual.pdf
"""Handle CJK characters in WeasyPrint PDFs."""
from weasyprint import HTML
# WeasyPrint supports any Unicode font installed on the system
cjk_html = """
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<style>
@page { size: A4; margin: 2cm; }
body {
font-family: 'Noto Sans CJK SC', 'Noto Sans SC', 'Source Han Sans',
'SimSun', 'Microsoft YaHei', sans-serif;
font-size: 11pt;
line-height: 1.8;
}
</style>
</head>
<body>
<h1>多语言文档 Multilingual Document 다국어 문서</h1>
<h2>中文 (Chinese)</h2>
<p>本报告分析了分布式系统在不同负载条件下的性能表现。
结果表明，使用事件驱动架构可以将延迟降低40%。</p>
<h2>日本語 (Japanese)</h2>
<p>本研究では、分散システムの性能を分析し、
イベント駆動アーキテクチャの利点を検証しました。</p>
<h2>한국어 (Korean)</h2>
<p>본 보고서는 분산 시스템의 성능을 다양한 부하 조건에서
분석하였으며, 이벤트 기반 아키텍처의 이점을 확인했습니다.</p>
</body>
</html>
"""
HTML(string=cjk_html).write_pdf('multilingual_report.pdf')
#!/bin/bash
# batch-convert.sh — Convert all markdown files in a directory to PDF
INPUT_DIR="./markdown_files"
OUTPUT_DIR="./pdf_output"
TEMPLATE="./templates/report.tex"
mkdir -p "$OUTPUT_DIR"
# Process all .md files
for md_file in "$INPUT_DIR"/*.md; do
filename=$(basename "$md_file" .md)
echo "Converting: $filename.md → $filename.pdf"
pandoc "$md_file" \
--template="$TEMPLATE" \
--pdf-engine=xelatex \
--toc \
--number-sections \
-o "$OUTPUT_DIR/$filename.pdf"
done
echo "Batch conversion complete. Files in: $OUTPUT_DIR"
"""Batch convert markdown files to PDF with progress tracking."""
import os
import glob
from pathlib import Path
import markdown
from weasyprint import HTML
from concurrent.futures import ProcessPoolExecutor, as_completed
def convert_single_file(md_path, output_dir, css_path):
"""Convert a single markdown file to PDF."""
try:
filename = Path(md_path).stem
output_path = os.path.join(output_dir, f"{filename}.pdf")
with open(md_path, 'r') as f:
md_content = f.read()
html = markdown.markdown(
md_content,
extensions=['tables', 'fenced_code', 'codehilite', 'toc']
)
with open(css_path, 'r') as f:
css = f.read()
full_html = f"""
<!DOCTYPE html>
<html>
<head><meta charset="utf-8"><style>{css}</style></head>
<body>{html}</body>
</html>
"""
HTML(string=full_html).write_pdf(output_path)
return (md_path, True, None)
except Exception as e:
return (md_path, False, str(e))
def batch_convert(input_dir, output_dir, css_path, max_workers=):
os.makedirs(output_dir, exist_ok=)
md_files = glob.glob(os.path.join(input_dir, ))
()
successful =
failed =
ProcessPoolExecutor(max_workers=max_workers) executor:
futures = {
executor.submit(convert_single_file, md, output_dir, css_path): md
md md_files
}
future as_completed(futures):
md_path, success, error = future.result()
filename = os.path.basename(md_path)
success:
successful +=
()
:
failed +=
()
()
batch_convert(, , )
| Criteria | 1 (Basic) | 2 (Functional) | 3 (Proficient) | 4 (Advanced) | 5 (Expert) |
|---|---|---|---|---|---|
| Quality | Plain output, no styling | Basic formatting, readable | Professional layout, consistent | Branded PDF, polished design | Publication-ready, print-quality |
| Performance | Single file only | Small batch (<10) | Batch (10-100) | Large batch (100+) with parallelism | Enterprise pipeline |
| Features | Text and headings | Images and tables | TOC, headers, footers | Syntax highlighting, CJK, metadata | Interactive elements, bookmarks |
| Customization | Default settings | Font changes | Template usage | Custom templates, CSS themes | Full programmatic control |
| Reliability | Manual process | Simple script | Error handling | Parallel processing | CI/CD pipeline, monitoring |
longtable in LaTeX or set table-layout: fixed in CSS.page-break-inside: avoid in CSS or \pagebreak in LaTeX.@page rules.--pdf-engine flag: Pandoc defaults to pdflatex which doesn't support all features. Switch to xelatex for Unicode/non-Latin scripts.@font-face; Pandoc requires system fonts.