445 lines
15 KiB
Python
445 lines
15 KiB
Python
import sys
|
||
import os
|
||
import re
|
||
from datetime import datetime
|
||
import argparse
|
||
|
||
# Dependency check
|
||
try:
|
||
from fpdf import FPDF
|
||
from fpdf.enums import XPos, YPos
|
||
from fpdf.fonts import FontFace
|
||
except ImportError:
|
||
import subprocess
|
||
subprocess.check_call([sys.executable, "-m", "pip", "install", "fpdf2"])
|
||
from fpdf import FPDF
|
||
from fpdf.enums import XPos, YPos
|
||
from fpdf.fonts import FontFace
|
||
|
||
# Assets
|
||
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
|
||
LOGO_PATH = os.path.join(BASE_DIR, "assets", "itguys_logo_main.png")
|
||
|
||
# Colors (Premium Palette)
|
||
COLOR_PRIMARY = (20, 120, 207) # #1478cf
|
||
COLOR_TEXT_MAIN = (50, 60, 70) # #323C46
|
||
COLOR_BG_LIGHT = (250, 250, 252)
|
||
COLOR_INFO_BG = (235, 245, 255)
|
||
COLOR_INFO_BORDER = (20, 120, 207)
|
||
COLOR_WARN_BG = (255, 248, 235)
|
||
COLOR_WARN_BORDER = (255, 165, 0)
|
||
|
||
# Regex Patterns (CommonMark-inspired for robustness)
|
||
RE_HEADER = re.compile(r'^(#{1,6})\s+(.*)$')
|
||
RE_UNORDERED_LIST = re.compile(r'^\s*[-+*]\s+(.+)$')
|
||
RE_ORDERED_LIST = re.compile(r'^\s*(\d+)[.)]\s+(.+)$')
|
||
RE_BLOCKQUOTE = re.compile(r'^>\s*(.*)$')
|
||
RE_TABLE_SEP = re.compile(r'^[\|\s\-:]+$')
|
||
RE_IMAGE = re.compile(r'!\[([^\]]*)\]\(([^)\s]+)(?:\s+"[^"]*")?\)')
|
||
RE_CODE_FENCE = re.compile(r'^```\s*(\w*)\s*$')
|
||
RE_CHECKBOX = re.compile(r'^\s*[-*+]\s*\[([ xX])\]\s+(.+)$')
|
||
|
||
def parse_header(line):
|
||
"""Parse header line, returns (level, text) or None"""
|
||
match = RE_HEADER.match(line.strip())
|
||
if match:
|
||
return len(match.group(1)), match.group(2).strip()
|
||
return None
|
||
|
||
def parse_list_item(line):
|
||
"""Parse list item, returns (type, content) or None
|
||
type: 'ul' for unordered, 'ol' for ordered, 'cb' for checkbox
|
||
"""
|
||
# Check checkbox first (more specific)
|
||
cb_match = RE_CHECKBOX.match(line)
|
||
if cb_match:
|
||
checked = cb_match.group(1).lower() == 'x'
|
||
return ('cb', cb_match.group(2), checked)
|
||
|
||
ul_match = RE_UNORDERED_LIST.match(line)
|
||
if ul_match:
|
||
return ('ul', ul_match.group(1), None)
|
||
|
||
ol_match = RE_ORDERED_LIST.match(line)
|
||
if ol_match:
|
||
return ('ol', ol_match.group(2), ol_match.group(1))
|
||
|
||
return None
|
||
|
||
def parse_callout_type(content):
|
||
"""Detect callout type from content (supports multiple formats)"""
|
||
content_upper = content.upper()
|
||
|
||
# GitHub style alerts [!NOTE], [!WARNING], etc.
|
||
if '[!WARNING]' in content_upper or '[!CAUTION]' in content_upper:
|
||
return 'WARN', re.sub(r'\[!(WARNING|CAUTION)\]', '', content, flags=re.IGNORECASE).strip()
|
||
if '[!IMPORTANT]' in content_upper:
|
||
return 'WARN', re.sub(r'\[!IMPORTANT\]', '', content, flags=re.IGNORECASE).strip()
|
||
if '[!NOTE]' in content_upper or '[!TIP]' in content_upper or '[!INFO]' in content_upper:
|
||
return 'INFO', re.sub(r'\[!(NOTE|TIP|INFO)\]', '', content, flags=re.IGNORECASE).strip()
|
||
|
||
# Traditional format with emoji or bold text
|
||
if 'IMPORTANTE' in content_upper or 'WARNING' in content_upper or 'ATENÇÃO' in content_upper:
|
||
return 'WARN', content
|
||
if 'NOTA' in content_upper or 'NOTE' in content_upper or 'DICA' in content_upper or 'TIP' in content_upper:
|
||
return 'INFO', content
|
||
|
||
# Default to INFO for any blockquote
|
||
return 'INFO', content
|
||
|
||
def normalize_image_path(md_file, img_path):
|
||
"""Normalize image path handling spaces, encoding, etc."""
|
||
try:
|
||
from urllib.parse import unquote
|
||
img_path = unquote(img_path.strip()) # Decode %20 etc.
|
||
except:
|
||
pass
|
||
|
||
cwd = os.path.dirname(md_file)
|
||
full_path = os.path.join(cwd, img_path)
|
||
|
||
# Try normalized path first
|
||
if os.path.exists(full_path):
|
||
return full_path
|
||
|
||
# Try absolute path
|
||
if os.path.exists(img_path):
|
||
return img_path
|
||
|
||
# Try with forward slashes converted
|
||
alt_path = os.path.join(cwd, img_path.replace('/', os.sep))
|
||
if os.path.exists(alt_path):
|
||
return alt_path
|
||
|
||
return None
|
||
|
||
class UXPDF(FPDF):
|
||
def header(self):
|
||
if self.page_no() > 1:
|
||
self.set_fill_color(255, 255, 255)
|
||
self.rect(0, 0, self.w, 25, 'F')
|
||
|
||
if os.path.exists(LOGO_PATH):
|
||
self.image(LOGO_PATH, x=10, y=8, h=10)
|
||
|
||
self.set_draw_color(*COLOR_PRIMARY)
|
||
self.set_line_width(0.5)
|
||
self.line(0, 25, self.w, 25)
|
||
|
||
self.set_font('Helvetica', 'B', 10)
|
||
self.set_text_color(*COLOR_PRIMARY)
|
||
self.set_y(10)
|
||
self.cell(0, 10, "MANUAL TÉCNICO", 0, new_x=XPos.RIGHT, new_y=YPos.TOP, align='R')
|
||
self.ln(20)
|
||
|
||
def footer(self):
|
||
# Ignora rodapé na capa (página 1)
|
||
if self.page_no() == 1:
|
||
return
|
||
|
||
self.set_y(-20)
|
||
self.set_font('Helvetica', 'I', 8)
|
||
self.set_text_color(100, 100, 100)
|
||
self.set_draw_color(220, 220, 220)
|
||
self.line(10, self.h-20, self.w-10, self.h-20)
|
||
|
||
self.set_y(-15)
|
||
self.cell(0, 10, 'iT Guys Solutions - Confidencial', 0, align='L')
|
||
self.set_x(0)
|
||
self.cell(0, 10, f'Página {self.page_no()}/{{nb}}', 0, align='R')
|
||
|
||
def clean_markdown(text):
|
||
text = text.replace('**', '').replace('`', '')
|
||
return text.encode('latin-1', 'replace').decode('latin-1')
|
||
|
||
def safe_text(text):
|
||
text = text.replace('ℹ️', '').replace('ℹ', '').replace('⚠️', '').replace('🚀', '')
|
||
text = text.replace('“', '"').replace('”', '"').replace('’', "'")
|
||
return text.encode('latin-1', 'replace').decode('latin-1')
|
||
|
||
def make_links_clickable(text):
|
||
text = re.sub(r'`(https?://[^`]+)`', r'[\1](\1)', text)
|
||
return text
|
||
|
||
def process_variables(text):
|
||
now = datetime.now()
|
||
replacements = {
|
||
'{{DATA_ATUAL}}': now.strftime("%d/%m/%Y"),
|
||
'{{ANO}}': str(now.year)
|
||
}
|
||
for k, v in replacements.items():
|
||
if k in text:
|
||
text = text.replace(k, v)
|
||
return text
|
||
|
||
def render_callout(pdf, text, type='INFO'):
|
||
pdf.ln(5)
|
||
saved_x = pdf.get_x()
|
||
saved_y = pdf.get_y()
|
||
|
||
if type == 'WARN' or '[IMPORTANTE]' in text:
|
||
bg = COLOR_WARN_BG
|
||
border = COLOR_WARN_BORDER
|
||
label = "IMPORTANTE"
|
||
else:
|
||
bg = COLOR_INFO_BG
|
||
border = COLOR_INFO_BORDER
|
||
label = "NOTA"
|
||
|
||
pdf.set_fill_color(*bg)
|
||
pdf.set_draw_color(*bg)
|
||
|
||
pdf.set_line_width(1.5)
|
||
pdf.set_draw_color(*border)
|
||
pdf.set_x(pdf.l_margin + 2)
|
||
|
||
pdf.set_font('Helvetica', 'B', 9)
|
||
pdf.set_text_color(*border)
|
||
pdf.cell(0, 5, label, new_x=XPos.LMARGIN, new_y=YPos.NEXT)
|
||
|
||
pdf.set_font('Helvetica', '', 10)
|
||
pdf.set_text_color(*COLOR_TEXT_MAIN)
|
||
pdf.set_x(pdf.l_margin + 2)
|
||
text = make_links_clickable(text)
|
||
pdf.multi_cell(0, 6, safe_text(text), fill=True, markdown=True)
|
||
|
||
end_y = pdf.get_y()
|
||
pdf.set_draw_color(*border)
|
||
pdf.line(pdf.l_margin, saved_y, pdf.l_margin, end_y)
|
||
|
||
# Reset colors explicitly to avoid bleeding
|
||
pdf.set_fill_color(255, 255, 255)
|
||
pdf.set_text_color(*COLOR_TEXT_MAIN)
|
||
pdf.ln(5)
|
||
|
||
def convert(md_file, pdf_file):
|
||
pdf = UXPDF()
|
||
pdf.set_auto_page_break(auto=True, margin=20)
|
||
pdf.set_title("Manual Técnico iT Guys")
|
||
|
||
# --- Cover Page ---
|
||
pdf.add_page()
|
||
pdf.set_fill_color(*COLOR_PRIMARY)
|
||
pdf.rect(0, 0, 15, 297, 'F')
|
||
|
||
if os.path.exists(LOGO_PATH):
|
||
pdf.image(LOGO_PATH, x=40, y=50, w=100)
|
||
|
||
# Extract Title from MD (Assume First H1)
|
||
# Generic placeholder if not found
|
||
doc_title = "Documentação Técnica"
|
||
doc_subtitle = "Guia Oficial iT Guys"
|
||
|
||
# Pre-read to find title for Cover
|
||
with open(md_file, 'r', encoding='utf-8') as f:
|
||
pre_lines = f.readlines()
|
||
for line in pre_lines:
|
||
if line.startswith('# '):
|
||
doc_title = line[2:].strip().replace('MANUAL TÉCNICO - ', '') # Cleanup
|
||
break
|
||
|
||
pdf.set_y(140)
|
||
pdf.set_x(30)
|
||
pdf.set_font('Helvetica', 'B', 32)
|
||
pdf.set_text_color(*COLOR_PRIMARY)
|
||
pdf.multi_cell(0, 12, safe_text(doc_title), align='L')
|
||
|
||
pdf.set_y(180)
|
||
pdf.set_x(30)
|
||
pdf.set_font('Helvetica', '', 16)
|
||
pdf.set_text_color(*COLOR_TEXT_MAIN)
|
||
pdf.multi_cell(0, 8, safe_text(doc_subtitle), align='L')
|
||
|
||
pdf.set_y(-30)
|
||
pdf.set_x(30)
|
||
pdf.set_font('Helvetica', 'B', 10)
|
||
pdf.set_text_color(*COLOR_PRIMARY)
|
||
pdf.cell(0, 10, "iT GUYS SOLUTIONS")
|
||
|
||
# Content
|
||
pdf.add_page()
|
||
|
||
with open(md_file, 'r', encoding='utf-8') as f:
|
||
lines = f.readlines()
|
||
|
||
in_code_block = False
|
||
table_buffer = []
|
||
first_h1_skipped = False
|
||
|
||
for i, line in enumerate(lines):
|
||
line = line.strip()
|
||
line = process_variables(line)
|
||
|
||
# Robust Reset at start of line processing
|
||
pdf.set_fill_color(255, 255, 255)
|
||
pdf.set_text_color(*COLOR_TEXT_MAIN)
|
||
pdf.set_font('Helvetica', '', 11)
|
||
|
||
# --- Tables ---
|
||
if line.startswith('|'):
|
||
table_buffer.append(line)
|
||
continue
|
||
|
||
if table_buffer:
|
||
headers = [c.strip() for c in table_buffer[0].split('|') if c.strip()]
|
||
data = []
|
||
for r_line in table_buffer[1:]:
|
||
if RE_TABLE_SEP.match(r_line): continue # Skip separator line
|
||
cols = [c.strip() for c in r_line.split('|') if c.strip()]
|
||
if cols: data.append(cols)
|
||
|
||
table_buffer = []
|
||
if headers:
|
||
pdf.ln(5)
|
||
pdf.set_draw_color(*COLOR_PRIMARY)
|
||
pdf.set_line_width(0.3)
|
||
|
||
is_tech_data = "Campo" in headers[0] or "Valor" in headers[1]
|
||
col_widths = (30, 70) if is_tech_data else None
|
||
|
||
with pdf.table(
|
||
text_align="LEFT",
|
||
col_widths=col_widths,
|
||
line_height=7
|
||
) as table:
|
||
row = table.row()
|
||
for h in headers:
|
||
h_clean = clean_markdown(h)
|
||
row.cell(h_clean, style=FontFace(emphasis="BOLD", color=(255,255,255), fill_color=COLOR_PRIMARY))
|
||
|
||
for d_row in data:
|
||
row = table.row()
|
||
for idx, d in enumerate(d_row):
|
||
d_clean = clean_markdown(d)
|
||
emphasis = None
|
||
if is_tech_data and idx == 0:
|
||
emphasis = "BOLD"
|
||
row.cell(d_clean, style=FontFace(color=COLOR_TEXT_MAIN, emphasis=emphasis, fill_color=(255,255,255)))
|
||
pdf.ln(5)
|
||
|
||
if not line:
|
||
if not in_code_block: pdf.ln(3)
|
||
continue
|
||
|
||
# Code fences (robust: accepts spaces after ```)
|
||
if RE_CODE_FENCE.match(line) or line.strip().startswith('```'):
|
||
in_code_block = not in_code_block
|
||
continue
|
||
|
||
if in_code_block:
|
||
pdf.set_font('Courier', '', 9.5)
|
||
pdf.set_text_color(50, 50, 50)
|
||
pdf.set_fill_color(245, 245, 245)
|
||
pdf.set_x(pdf.l_margin + 5)
|
||
pdf.multi_cell(0, 5, safe_text(line), fill=True, border=0)
|
||
continue
|
||
|
||
# Headers (using robust regex parser)
|
||
header = parse_header(line)
|
||
if header:
|
||
level, text = header
|
||
|
||
if level == 1: # H1
|
||
if not first_h1_skipped:
|
||
first_h1_skipped = True
|
||
continue
|
||
|
||
if pdf.page_no() > 2 or pdf.get_y() > 60:
|
||
pdf.add_page()
|
||
|
||
pdf.set_font('Helvetica', 'B', 20)
|
||
pdf.set_text_color(*COLOR_PRIMARY)
|
||
pdf.multi_cell(0, 10, safe_text(text), fill=False)
|
||
pdf.ln(5)
|
||
y = pdf.get_y()
|
||
pdf.set_draw_color(*COLOR_PRIMARY)
|
||
pdf.line(pdf.l_margin, y, 210-pdf.r_margin, y)
|
||
pdf.ln(10)
|
||
|
||
elif level == 2: # H2
|
||
pdf.ln(8)
|
||
pdf.set_font('Helvetica', 'B', 14)
|
||
pdf.set_text_color(*COLOR_PRIMARY)
|
||
pdf.multi_cell(0, 8, safe_text(text), fill=False)
|
||
pdf.ln(2)
|
||
|
||
elif level == 3: # H3
|
||
pdf.ln(4)
|
||
pdf.set_font('Helvetica', 'B', 12)
|
||
pdf.set_text_color(*COLOR_TEXT_MAIN)
|
||
pdf.multi_cell(0, 6, safe_text(text), fill=False)
|
||
|
||
elif level >= 4: # H4+
|
||
pdf.ln(3)
|
||
pdf.set_font('Helvetica', 'B', 11)
|
||
pdf.set_text_color(*COLOR_TEXT_MAIN)
|
||
pdf.multi_cell(0, 5, safe_text(text), fill=False)
|
||
|
||
continue
|
||
|
||
# Images (robust path handling)
|
||
img_match = RE_IMAGE.search(line)
|
||
if img_match or (line.startswith(':
|
||
if img_match:
|
||
img_path = img_match.group(2)
|
||
else:
|
||
match = re.search(r'\(([^)]+)\)', line)
|
||
img_path = match.group(1) if match else None
|
||
|
||
if img_path:
|
||
full_path = normalize_image_path(md_file, img_path)
|
||
if full_path:
|
||
pdf.ln(5)
|
||
try:
|
||
x = (pdf.w - 110)/2
|
||
pdf.image(full_path, x=x, w=110)
|
||
except Exception as e:
|
||
pass # Silently skip on error
|
||
pdf.ln(5)
|
||
continue
|
||
|
||
# Blockquotes/Callouts (robust detection)
|
||
bq_match = RE_BLOCKQUOTE.match(line)
|
||
if bq_match or line.startswith('>'):
|
||
content = bq_match.group(1) if bq_match else line[1:].strip()
|
||
c_type, clean_content = parse_callout_type(content)
|
||
render_callout(pdf, clean_content, c_type)
|
||
continue
|
||
|
||
# Lists and regular text (robust detection)
|
||
pdf.set_fill_color(255, 255, 255)
|
||
pdf.set_font('Helvetica', '', 11)
|
||
pdf.set_text_color(*COLOR_TEXT_MAIN)
|
||
|
||
list_item = parse_list_item(line)
|
||
line_processed = make_links_clickable(line)
|
||
|
||
if list_item:
|
||
item_type, content, extra = list_item
|
||
pdf.set_x(pdf.l_margin + 6)
|
||
if item_type == 'cb':
|
||
# Checkbox
|
||
checkbox = '[x]' if extra else '[ ]'
|
||
pdf.multi_cell(0, 7, safe_text(f"{checkbox} {content}"), markdown=True, fill=False)
|
||
else:
|
||
pdf.multi_cell(0, 7, safe_text(line_processed), markdown=True, fill=False)
|
||
else:
|
||
pdf.set_x(pdf.l_margin)
|
||
pdf.multi_cell(0, 7, safe_text(line_processed), markdown=True, fill=False)
|
||
|
||
pdf.output(pdf_file)
|
||
print(f"PDF Generated: {pdf_file}")
|
||
|
||
if __name__ == "__main__":
|
||
if len(sys.argv) < 2:
|
||
print("Usage: python convert_to_pdf.py <input.md> [output.pdf]")
|
||
sys.exit(1)
|
||
|
||
md_in = sys.argv[1]
|
||
if len(sys.argv) >= 3:
|
||
pdf_out = sys.argv[2]
|
||
else:
|
||
pdf_out = os.path.splitext(md_in)[0] + ".pdf"
|
||
|
||
convert(md_in, pdf_out)
|