"""
MarkdownMuse: A Python application for converting Markdown to beautifully formatted PDFs
This module implements the core functionality needed for the MarkdownMuse application.
"""
import os
import re
import sys
import glob
import logging
from typing import List, Dict, Any, Optional, Tuple
from bs4 import BeautifulSoup
import markdown
from markdown.extensions.tables import TableExtension
from markdown.extensions.fenced_code import FencedCodeExtension
from markdown.extensions.toc import TocExtension
from reportlab.lib.pagesizes import letter, A4
from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
from reportlab.lib.units import inch
from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle, Image, PageBreak, Preformatted, ListFlowable, ListItem
from reportlab.lib.colors import HexColor, black, grey
from reportlab.lib import colors
from reportlab.lib.enums import TA_LEFT, TA_CENTER, TA_RIGHT
import html
import base64
import requests
from PIL import Image as PilImage
import io
import tempfile
# Set up logging
logging.basicConfig(
level=logging.INFO,
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)
class MarkdownToPDFConverter:
"""
Class to convert Markdown content to PDF using ReportLab.
"""
def __init__(
self,
output_path: str = "output.pdf",
page_size: str = "A4",
margins: Tuple[float, float, float, float] = (0.75, 0.75, 0.75, 0.75),
font_name: str = "Helvetica",
base_font_size: int = 10,
heading_scale: Dict[int, float] = None,
include_toc: bool = True,
code_style: str = "github"
):
"""
Initialize the converter with configuration options.
Args:
output_path: Path to save the PDF
page_size: Page size ("A4" or "letter")
margins: Tuple of margins (left, right, top, bottom) in inches
font_name: Base font name to use
base_font_size: Base font size in points
heading_scale: Dictionary of heading levels to font size multipliers
include_toc: Whether to include a table of contents
code_style: Style to use for code blocks
"""
self.output_path = output_path
self.page_size = A4 if page_size.upper() == "A4" else letter
self.margins = margins
self.font_name = font_name
self.base_font_size = base_font_size
self.heading_scale = heading_scale or {
1: 2.0, # H1 is 2.0x base font size
2: 1.7, # H2 is 1.7x base font size
3: 1.4, # H3 is 1.4x base font size
4: 1.2, # H4 is 1.2x base font size
5: 1.1, # H5 is 1.1x base font size
6: 1.0 # H6 is 1.0x base font size
}
self.include_toc = include_toc
self.code_style = code_style
# Initialize styles
self.styles = getSampleStyleSheet()
self._setup_styles()
# Initialize document elements
self.elements = []
self.toc_entries = []
def _setup_styles(self) -> None:
"""Set up custom paragraph styles for the document."""
# Modify existing Normal style
self.styles['Normal'].fontName = self.font_name
self.styles['Normal'].fontSize = self.base_font_size
self.styles['Normal'].leading = self.base_font_size * 1.2
self.styles['Normal'].spaceAfter = self.base_font_size * 0.8
# Heading styles
for level in range(1, 7):
size_multiplier = self.heading_scale.get(level, 1.0)
heading_name = f'Heading{level}'
# Check if the heading style already exists
if heading_name in self.styles:
# Modify existing style
self.styles[heading_name].parent = self.styles['Normal']
self.styles[heading_name].fontName = f'{self.font_name}-Bold'
self.styles[heading_name].fontSize = int(self.base_font_size * size_multiplier)
self.styles[heading_name].leading = int(self.base_font_size * size_multiplier * 1.2)
self.styles[heading_name].spaceAfter = self.base_font_size
self.styles[heading_name].spaceBefore = self.base_font_size * (1 + (0.2 * (7 - level)))
else:
# Create new style
self.styles.add(
ParagraphStyle(
name=heading_name,
parent=self.styles['Normal'],
fontName=f'{self.font_name}-Bold',
fontSize=int(self.base_font_size * size_multiplier),
leading=int(self.base_font_size * size_multiplier * 1.2),
spaceAfter=self.base_font_size,
spaceBefore=self.base_font_size * (1 + (0.2 * (7 - level))),
)
)
# Code block style
self.styles.add(
ParagraphStyle(
name='CodeBlock',
fontName='Courier',
fontSize=self.base_font_size * 0.9,
leading=self.base_font_size * 1.1,
spaceAfter=self.base_font_size,
spaceBefore=self.base_font_size,
leftIndent=self.base_font_size,
backgroundColor=HexColor('#EEEEEE'),
borderWidth=0,
borderPadding=self.base_font_size * 0.5,
)
)
# List item style
self.styles.add(
ParagraphStyle(
name='ListItem',
parent=self.styles['Normal'],
leftIndent=self.base_font_size * 2,
firstLineIndent=-self.base_font_size,
)
)
# Table of contents styles
self.styles.add(
ParagraphStyle(
name='TOCHeading',
parent=self.styles['Heading1'],
fontSize=int(self.base_font_size * 1.5),
spaceAfter=self.base_font_size * 1.5,
)
)
for level in range(1, 4): # Create styles for TOC levels
self.styles.add(
ParagraphStyle(
name=f'TOC{level}',
parent=self.styles['Normal'],
leftIndent=self.base_font_size * (level - 1) * 2,
fontSize=self.base_font_size - (level - 1),
leading=self.base_font_size * 1.4,
)
)
def convert_file(self, md_file_path: str) -> None:
"""
Convert a single markdown file to PDF.
Args:
md_file_path: Path to the markdown file
"""
# Read markdown content
with open(md_file_path, 'r', encoding='utf-8') as f:
md_content = f.read()
# Convert markdown to PDF
self.convert_content(md_content)
def convert_content(self, md_content: str) -> None:
"""
Convert markdown content string to PDF.
Args:
md_content: Markdown content as a string
"""
# Convert markdown to HTML
html_content = self._md_to_html(md_content)
# Convert HTML to ReportLab elements
self._html_to_elements(html_content)
# Generate the PDF
self._generate_pdf()
logger.info(f"PDF created at {self.output_path}")
def convert_multiple_files(self, md_file_paths: List[str],
merge: bool = True,
separate_toc: bool = False) -> None:
"""
Convert multiple markdown files to PDF.
Args:
md_file_paths: List of paths to markdown files
merge: Whether to merge all files into a single PDF
separate_toc: Whether to include a separate TOC for each file
"""
if merge:
all_content = []
for file_path in md_file_paths:
logger.info(f"Processing {file_path}")
with open(file_path, 'r', encoding='utf-8') as f:
content = f.read()
# Add file name as heading if more than one file
if len(md_file_paths) > 1:
file_name = os.path.splitext(os.path.basename(file_path))[0]
content = f"# {file_name}\n\n{content}"
# Add page break between files
if all_content:
all_content.append("\n\n\n\n")
all_content.append(content)
combined_content = "\n".join(all_content)
self.convert_content(combined_content)
else:
# Process each file separately
for i, file_path in enumerate(md_file_paths):
converter = MarkdownToPDFConverter(
output_path=f"{os.path.splitext(file_path)[0]}.pdf",
page_size=self.page_size,
margins=self.margins,
font_name=self.font_name,
base_font_size=self.base_font_size,
heading_scale=self.heading_scale,
include_toc=separate_toc,
code_style=self.code_style
)
converter.convert_file(file_path)
def _md_to_html(self, md_content: str) -> str:
"""
Convert markdown content to HTML.
Args:
md_content: Markdown content
Returns:
HTML content
"""
# Define extensions for markdown conversion
extensions = [
'markdown.extensions.extra',
'markdown.extensions.smarty',
TableExtension(),
FencedCodeExtension(),
TocExtension(toc_depth=3) if self.include_toc else None
]
# Remove None values
extensions = [ext for ext in extensions if ext is not None]
# Convert markdown to HTML
html_content = markdown.markdown(md_content, extensions=extensions)
return html_content
def _html_to_elements(self, html_content: str) -> None:
"""
Convert HTML content to ReportLab elements.
Args:
html_content: HTML content
"""
soup = BeautifulSoup(html_content, 'html.parser')
# Process elements
for element in soup.children:
if element.name:
self._process_element(element)
def _process_element(self, element: BeautifulSoup) -> None:
"""
Process an HTML element and convert it to ReportLab elements.
Args:
element: BeautifulSoup element
"""
if element.name in ['h1', 'h2', 'h3', 'h4', 'h5', 'h6']:
level = int(element.name[1])
text = element.get_text()
# Add to TOC
if self.include_toc:
self.toc_entries.append((level, text))
# Create heading paragraph
self.elements.append(
Paragraph(text, self.styles[f'Heading{level}'])
)
elif element.name == 'p':
text = self._process_inline_elements(element)
self.elements.append(
Paragraph(text, self.styles['Normal'])
)
elif element.name == 'pre':
code = element.get_text()
self.elements.append(
Preformatted(code, self.styles['CodeBlock'])
)
elif element.name == 'img':
src = element.get('src', '')
alt = element.get('alt', 'Image')
# Handle different image sources
if src.startswith('http'):
# Remote image
try:
response = requests.get(src)
img_data = response.content
img_stream = io.BytesIO(img_data)
image = Image(img_stream, width=4*inch, height=3*inch)
# Try to get actual dimensions
try:
pil_img = PilImage.open(img_stream)
width, height = pil_img.size
aspect = width / height
max_width = 6 * inch
if width > max_width:
new_width = max_width
new_height = new_width / aspect
image = Image(img_stream, width=new_width, height=new_height)
except:
pass # Use default size if image can't be processed
self.elements.append(image)
except:
# If image can't be retrieved, add a placeholder
self.elements.append(
Paragraph(f"[Image: {alt}]", self.styles['Normal'])
)
elif src.startswith('data:image'):
# Base64 encoded image
try:
# Extract base64 data
b64_data = src.split(',')[1]
img_data = base64.b64decode(b64_data)
img_stream = io.BytesIO(img_data)
image = Image(img_stream, width=4*inch, height=3*inch)
self.elements.append(image)
except:
# If image can't be processed, add a placeholder
self.elements.append(
Paragraph(f"[Image: {alt}]", self.styles['Normal'])
)
else:
# Local image
if os.path.exists(src):
image = Image(src, width=4*inch, height=3*inch)
self.elements.append(image)
else:
# If image can't be found, add a placeholder
self.elements.append(
Paragraph(f"[Image: {alt}]", self.styles['Normal'])
)
elif element.name == 'ul' or element.name == 'ol':
list_items = []
bullet_type = 'bullet' if element.name == 'ul' else 'numbered'
for item in element.find_all('li', recursive=False):
text = self._process_inline_elements(item)
list_items.append(
ListItem(
Paragraph(text, self.styles['ListItem']),
leftIndent=20
)
)
self.elements.append(
ListFlowable(
list_items,
bulletType=bullet_type,
start=1 if bullet_type == 'numbered' else None,
bulletFormat='%s.' if bullet_type == 'numbered' else '%s'
)
)
elif element.name == 'table':
self._process_table(element)
elif element.name == 'div' and 'page-break' in element.get('class', []):
self.elements.append(PageBreak())
elif element.name == 'hr':
self.elements.append(Spacer(1, 0.25*inch))
# Process children for complex elements
elif element.name in ['div', 'blockquote', 'section', 'article']:
for child in element.children:
if hasattr(child, 'name') and child.name:
self._process_element(child)
def _process_inline_elements(self, element: BeautifulSoup) -> str:
"""
Process inline HTML elements like bold, italic, etc.
Args:
element: BeautifulSoup element
Returns:
Formatted text with ReportLab markup
"""
html_str = str(element)
# Convert common HTML tags to ReportLab paragraph markup
replacements = [
(r'(.*?)', r'\1'),
(r'(.*?)', r'\1'),
(r'(.*?)', r'\1'),
(r'(.*?)', r'\1'),
(r'(.*?)', r'\1'),
(r'(.*?)', r'\2'),
(r'(.*?)', r'\1'),
(r'(.*?)', r'\1'),
(r'(.*?)', r'\1'),
]
for pattern, replacement in replacements:
html_str = re.sub(pattern, replacement, html_str, flags=re.DOTALL)
# Extract text with our ReportLab markup from the modified HTML
soup = BeautifulSoup(html_str, 'html.parser')
return soup.get_text()
def _process_table(self, table_element: BeautifulSoup) -> None:
"""
Process an HTML table into a ReportLab Table.
Args:
table_element: BeautifulSoup table element
"""
rows = []
# Extract header row
thead = table_element.find('thead')
if thead:
header_cells = []
for th in thead.find_all(['th']):
text = self._process_inline_elements(th)
# Create a paragraph with bold text for headers
header_cells.append(Paragraph(f"{text}", self.styles['Normal']))
rows.append(header_cells)
# Extract body rows
tbody = table_element.find('tbody') or table_element
for tr in tbody.find_all('tr'):
if tr.parent.name == 'thead':
continue # Skip header rows already processed
row_cells = []
for cell in tr.find_all(['td', 'th']):
text = self._process_inline_elements(cell)
if cell.name == 'th':
# Headers are bold
row_cells.append(Paragraph(f"{text}", self.styles['Normal']))
else:
row_cells.append(Paragraph(text, self.styles['Normal']))
if row_cells: # Only add non-empty rows
rows.append(row_cells)
if rows:
# Create table and style
col_widths = [None] * len(rows[0]) # Auto width for columns
table = Table(rows, colWidths=col_widths)
# Add basic grid and header styling
style = TableStyle([
('GRID', (0, 0), (-1, -1), 0.5, colors.Color(0.7, 0.7, 0.7)),
('BACKGROUND', (0, 0), (-1, 0), colors.Color(0.8, 0.8, 0.8)),
('TEXTCOLOR', (0, 0), (-1, 0), colors.black),
('ALIGN', (0, 0), (-1, 0), 'CENTER'),
('FONTNAME', (0, 0), (-1, 0), f'{self.font_name}-Bold'),
('BOTTOMPADDING', (0, 0), (-1, 0), 8),
('TOPPADDING', (0, 0), (-1, 0), 8),
('BOTTOMPADDING', (0, 1), (-1, -1), 6),
('TOPPADDING', (0, 1), (-1, -1), 6),
])
table.setStyle(style)
self.elements.append(table)
# Add some space after the table
self.elements.append(Spacer(1, 0.1*inch))
def _generate_toc(self) -> None:
"""Generate a table of contents."""
if not self.toc_entries:
return
self.elements.append(Paragraph("Table of Contents", self.styles['TOCHeading']))
self.elements.append(Spacer(1, 0.2*inch))
for level, text in self.toc_entries:
if level <= 3: # Only include headings up to level 3
self.elements.append(
Paragraph(text, self.styles[f'TOC{level}'])
)
self.elements.append(PageBreak())
def _generate_pdf(self) -> None:
"""Generate the PDF document."""
# Create the document
doc = SimpleDocTemplate(
self.output_path,
pagesize=self.page_size,
leftMargin=self.margins[0]*inch,
rightMargin=self.margins[1]*inch,
topMargin=self.margins[2]*inch,
bottomMargin=self.margins[3]*inch
)
# Add TOC if requested
if self.include_toc and self.toc_entries:
self._generate_toc()
# Build the PDF
doc.build(self.elements)
class MarkdownToPDFAgent:
"""
AI Agent to convert Markdown files to PDF with enhanced formatting.
"""
def __init__(self, llm=None):
"""
Initialize the agent with optional LLM for content enhancement.
Args:
llm: Optional language model for content enhancement
"""
self.llm = llm
self.converter = MarkdownToPDFConverter()
def setup_from_openai(self, api_key=None):
"""
Setup agent with OpenAI LLM.
Args:
api_key: OpenAI API key (will use env var if not provided)
"""
try:
from langchain_openai import ChatOpenAI
api_key = api_key or os.getenv("OPENAI_API_KEY")
if not api_key:
logger.warning("No OpenAI API key provided. Agent will run without LLM enhancement.")
return False
self.llm = ChatOpenAI(
model="gpt-4",
temperature=0.1,
api_key=api_key
)
return True
except ImportError:
logger.warning("LangChain OpenAI package not found. Install with 'pip install langchain-openai'")
return False
def setup_from_gemini(self, api_key=None):
"""
Setup agent with Google Gemini LLM.
Args:
api_key: Google Gemini API key (will use env var if not provided)
"""
try:
from langchain_google_genai import ChatGoogleGenerativeAI
api_key = api_key or os.getenv("GOOGLE_API_KEY")
if not api_key:
logger.warning("No Google API key provided. Agent will run without LLM enhancement.")
return False
try:
# Use the latest Gemini model version
self.llm = ChatGoogleGenerativeAI(
model="gemini-1.5-flash",
temperature=0.1,
google_api_key=api_key,
convert_system_message_to_human=True
)
logger.info("Successfully set up Google Gemini LLM")
return True
except Exception as e:
logger.error(f"Error setting up Google Gemini LLM: {str(e)}")
return False
except ImportError:
logger.warning("LangChain Google Generative AI package not found. Install with 'pip install langchain-google-genai'")
return False
def enhance_markdown(self, content: str, instructions: str = None) -> str:
"""
Enhance markdown content using LLM if available.
Args:
content: Original markdown content
instructions: Specific enhancement instructions
Returns:
Enhanced markdown content
"""
if not self.llm:
logger.warning("No LLM available for enhancement. Returning original content.")
return content
default_instructions = """
Enhance this markdown content while preserving its structure and meaning.
Make the following improvements:
1. Fix any grammar or spelling issues
2. Improve formatting for better readability
3. Ensure proper markdown syntax is used
4. Add appropriate section headings if missing
5. Keep the content factually identical to the original
"""
instructions = instructions or default_instructions
try:
# Create a prompt for the LLM
prompt = f"{instructions}\n\nOriginal content:\n\n{content}\n\nPlease provide the enhanced markdown content:"
# Use the LLM directly with proper error handling
try:
from langchain.schema import HumanMessage
logger.info(f"Using LLM type: {type(self.llm).__name__}")
messages = [HumanMessage(content=prompt)]
result = self.llm.invoke(messages).content
logger.info("Successfully received response from LLM")
except Exception as e:
logger.error(f"Error invoking LLM: {str(e)}")
return content
# Clean up the result (extract just the markdown part)
result = self._clean_agent_output(result)
return result
except Exception as e:
logger.error(f"Error enhancing markdown: {str(e)}")
return content # Return original content if enhancement fails
def _clean_agent_output(self, output: str) -> str:
"""
Clean up agent output to extract just the markdown content.
Args:
output: Raw agent output
Returns:
Cleaned markdown content
"""
# Check if the output is wrapped in markdown code blocks
md_pattern = r"```(?:markdown|md)?\s*([\s\S]*?)```"
match = re.search(md_pattern, output)
if match:
return match.group(1).strip()
# If no markdown blocks found, remove any agent commentary
lines = output.split('\n')
result_lines = []
capture = False
for line in lines:
if capture or not (line.startswith("I") or line.startswith("Here") or line.startswith("The")):
capture = True
result_lines.append(line)
return '\n'.join(result_lines)
def process_file(self, input_path: str, output_path: str = None, enhance: bool = False,
enhancement_instructions: str = None, page_size: str = "A4") -> str:
"""
Process a single markdown file and convert it to PDF.
Args:
input_path: Path to input markdown file
output_path: Path for output PDF (defaults to input path with .pdf extension)
enhance: Whether to enhance the content with LLM
enhancement_instructions: Specific instructions for enhancement
page_size: Page size for the PDF ("A4" or "letter")
Returns:
Path to the generated PDF
"""
# Validate input file
if not os.path.exists(input_path):
logger.error(f"Input file not found: {input_path}")
return None
# Set default output path if not provided
if not output_path:
output_path = os.path.splitext(input_path)[0] + ".pdf"
# Read markdown content
with open(input_path, 'r', encoding='utf-8') as f:
content = f.read()
# Enhance content if requested
if enhance and self.llm:
logger.info(f"Enhancing content for {input_path}")
content = self.enhance_markdown(content, enhancement_instructions)
# Configure converter
self.converter = MarkdownToPDFConverter(
output_path=output_path,
page_size=page_size
)
# Convert to PDF
logger.info(f"Converting {input_path} to PDF")
self.converter.convert_content(content)
return output_path
def process_directory(self, input_dir: str, output_dir: str = None, pattern: str = "*.md",
enhance: bool = False, merge: bool = False,
output_filename: str = "merged_document.pdf",
page_size: str = "A4") -> List[str]:
"""
Process all markdown files in a directory.
Args:
input_dir: Path to input directory
output_dir: Path to output directory (defaults to input directory)
pattern: Glob pattern for markdown files
enhance: Whether to enhance content with LLM
merge: Whether to merge all files into a single PDF
output_filename: Filename for merged PDF
page_size: Page size for the PDF ("A4" or "letter")
Returns:
List of paths to generated PDFs
"""
# Validate input directory
if not os.path.isdir(input_dir):
logger.error(f"Input directory not found: {input_dir}")
return []
# Set default output directory if not provided
if not output_dir:
output_dir = input_dir
elif not os.path.exists(output_dir):
os.makedirs(output_dir)
# Get all markdown files
md_files = glob.glob(os.path.join(input_dir, pattern))
if not md_files:
logger.warning(f"No markdown files found in {input_dir} with pattern {pattern}")
return []
# Sort files to ensure consistent ordering
md_files.sort()
if merge:
logger.info(f"Merging {len(md_files)} markdown files into a single PDF")
# Process each file for enhancement if requested
if enhance and self.llm:
enhanced_contents = []
for md_file in md_files:
logger.info(f"Enhancing content for {md_file}")
with open(md_file, 'r', encoding='utf-8') as f:
content = f.read()
# Add file name as heading
file_name = os.path.splitext(os.path.basename(md_file))[0]
content = f"# {file_name}\n\n{content}"
enhanced_content = self.enhance_markdown(content)
enhanced_contents.append(enhanced_content)
# Merge enhanced contents with page breaks
merged_content = "\n\n\n\n".join(enhanced_contents)
# Convert merged content
output_path = os.path.join(output_dir, output_filename)
self.converter = MarkdownToPDFConverter(
output_path=output_path,
page_size=page_size
)
self.converter.convert_content(merged_content)
return [output_path]
else:
# Merge without enhancement
output_path = os.path.join(output_dir, output_filename)
self.converter = MarkdownToPDFConverter(
output_path=output_path,
page_size=page_size
)
self.converter.convert_multiple_files(md_files, merge=True)
return [output_path]
else:
# Process each file individually
output_files = []
for md_file in md_files:
output_filename = os.path.splitext(os.path.basename(md_file))[0] + ".pdf"
output_path = os.path.join(output_dir, output_filename)
processed_file = self.process_file(
md_file,
output_path,
enhance=enhance,
page_size=page_size
)
if processed_file:
output_files.append(processed_file)
return output_files