Import project files
This commit is contained in:
709
docling/app/services/docling_adapter.py
Normal file
709
docling/app/services/docling_adapter.py
Normal file
@@ -0,0 +1,709 @@
|
||||
from pathlib import Path
|
||||
from typing import Optional, Tuple, Dict, List, Any
|
||||
from urllib.parse import urlparse, unquote
|
||||
import os
|
||||
import re
|
||||
import io
|
||||
from bs4 import BeautifulSoup
|
||||
from bs4.element import PageElement
|
||||
import marko
|
||||
import sys
|
||||
try:
|
||||
_DOC_BASE = Path(__file__).resolve().parents[2] / "docling"
|
||||
p = str(_DOC_BASE)
|
||||
if p not in sys.path:
|
||||
sys.path.insert(0, p)
|
||||
except Exception:
|
||||
pass
|
||||
try:
|
||||
from docling.document_converter import DocumentConverter
|
||||
except Exception:
|
||||
class DocumentConverter: # type: ignore
|
||||
def __init__(self, *args, **kwargs):
|
||||
pass
|
||||
def convert(self, source):
|
||||
raise RuntimeError("docling not available")
|
||||
from docx import Document
|
||||
from docx.shared import Mm, Pt
|
||||
from docx.enum.section import WD_SECTION
|
||||
from docx.enum.text import WD_PARAGRAPH_ALIGNMENT
|
||||
from docx.oxml import OxmlElement
|
||||
from docx.oxml.ns import qn
|
||||
from urllib.request import urlopen
|
||||
import json
|
||||
|
||||
try:
|
||||
from weasyprint import HTML, CSS # type: ignore
|
||||
except Exception:
|
||||
HTML = None
|
||||
CSS = None
|
||||
|
||||
_mdit: Any = None
|
||||
_tasklists_plugin: Any = None
|
||||
_deflist_plugin: Any = None
|
||||
_footnote_plugin: Any = None
|
||||
_attrs_plugin: Any = None
|
||||
_HAS_MD_IT: bool = False
|
||||
try:
|
||||
import markdown_it as _mdit # type: ignore
|
||||
from mdit_py_plugins.tasklists import tasklists_plugin as _tasklists_plugin # type: ignore
|
||||
from mdit_py_plugins.deflist import deflist_plugin as _deflist_plugin # type: ignore
|
||||
from mdit_py_plugins.footnote import footnote_plugin as _footnote_plugin # type: ignore
|
||||
from mdit_py_plugins.attrs import attrs_plugin as _attrs_plugin # type: ignore
|
||||
_HAS_MD_IT = True
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
converter = DocumentConverter()
|
||||
LINKMAP_PATH = Path(__file__).resolve().parent.parent / "configs" / "linkmap" / "linkmap.json"
|
||||
_LINKMAP: Dict[str, str] = {}
|
||||
|
||||
def load_linkmap() -> Dict[str, str]:
|
||||
global _LINKMAP
|
||||
try:
|
||||
if LINKMAP_PATH.exists():
|
||||
_LINKMAP = json.loads(LINKMAP_PATH.read_text("utf-8")) or {}
|
||||
except Exception:
|
||||
_LINKMAP = {}
|
||||
return _LINKMAP
|
||||
|
||||
def save_linkmap(mapping: Dict[str, str]) -> None:
|
||||
LINKMAP_PATH.parent.mkdir(parents=True, exist_ok=True)
|
||||
LINKMAP_PATH.write_text(json.dumps(mapping, ensure_ascii=False, indent=2), "utf-8")
|
||||
load_linkmap()
|
||||
|
||||
def resolve_link(href: Optional[str], data_doc: Optional[str]) -> Optional[str]:
|
||||
if href:
|
||||
return href
|
||||
if not _LINKMAP:
|
||||
load_linkmap()
|
||||
if data_doc and data_doc in _LINKMAP:
|
||||
return _LINKMAP[data_doc]
|
||||
return None
|
||||
|
||||
def export_payload(doc, fmt: str) -> Tuple[str, str]:
|
||||
f = fmt.lower()
|
||||
if f == "markdown":
|
||||
return doc.export_to_markdown(), "text/markdown"
|
||||
if f == "html":
|
||||
return doc.export_to_html(), "text/html"
|
||||
if f == "json":
|
||||
return doc.export_to_json(), "application/json"
|
||||
if f == "doctags":
|
||||
return doc.export_to_doctags(), "application/json"
|
||||
raise ValueError("unsupported export")
|
||||
|
||||
def infer_basename(source_url: Optional[str], upload_name: Optional[str]) -> str:
|
||||
if source_url:
|
||||
path = urlparse(source_url).path
|
||||
name = os.path.basename(path) or "document"
|
||||
name = unquote(name)
|
||||
return os.path.splitext(name)[0] or "document"
|
||||
if upload_name:
|
||||
name = os.path.splitext(os.path.basename(upload_name))[0] or "document"
|
||||
return name
|
||||
return "document"
|
||||
|
||||
def sanitize_filename(name: Optional[str]) -> str:
|
||||
if not name:
|
||||
return "document"
|
||||
name = name.strip()[:128]
|
||||
name = re.sub(r'[<>:"/\\|?*\x00-\x1F]', "_", name) or "document"
|
||||
return name
|
||||
|
||||
def convert_source(source: str, export: str) -> Tuple[str, str]:
|
||||
result = converter.convert(source)
|
||||
return export_payload(result.document, export)
|
||||
|
||||
|
||||
|
||||
def md_to_docx_bytes(md: str, toc: bool = False, header_text: Optional[str] = None, footer_text: Optional[str] = None, logo_url: Optional[str] = None, copyright_text: Optional[str] = None, filename_text: Optional[str] = None, cover_src: Optional[str] = None, product_name: Optional[str] = None, document_name: Optional[str] = None, product_version: Optional[str] = None, document_version: Optional[str] = None) -> bytes:
|
||||
try:
|
||||
import logging as _log
|
||||
_log.info(f"md_to_docx_bytes start toc={toc} header={bool(header_text)} footer={bool(footer_text)} logo={bool(logo_url)} cover={bool(cover_src)}")
|
||||
except Exception:
|
||||
pass
|
||||
def _add_field(paragraph, instr: str):
|
||||
r1 = paragraph.add_run()
|
||||
b = OxmlElement('w:fldChar')
|
||||
b.set(qn('w:fldCharType'), 'begin')
|
||||
r1._r.append(b)
|
||||
r2 = paragraph.add_run()
|
||||
t = OxmlElement('w:instrText')
|
||||
t.set(qn('xml:space'), 'preserve')
|
||||
t.text = instr
|
||||
r2._r.append(t)
|
||||
r3 = paragraph.add_run()
|
||||
e = OxmlElement('w:fldChar')
|
||||
e.set(qn('w:fldCharType'), 'end')
|
||||
r3._r.append(e)
|
||||
def _available_width(section) -> int:
|
||||
return section.page_width - section.left_margin - section.right_margin
|
||||
def _fetch_bytes(u: str) -> Optional[bytes]:
|
||||
try:
|
||||
if u.lower().startswith('http://') or u.lower().startswith('https://'):
|
||||
with urlopen(u, timeout=10) as r:
|
||||
return r.read()
|
||||
p = Path(u)
|
||||
if p.exists() and p.is_file():
|
||||
return p.read_bytes()
|
||||
except Exception:
|
||||
return None
|
||||
return None
|
||||
html = normalize_html(md, options={
|
||||
"toc": "1" if toc else "",
|
||||
"header_text": header_text,
|
||||
"footer_text": footer_text,
|
||||
"logo_url": logo_url,
|
||||
"copyright_text": copyright_text,
|
||||
"filename_text": filename_text,
|
||||
"cover_src": cover_src,
|
||||
"product_name": product_name,
|
||||
"document_name": document_name,
|
||||
"product_version": product_version,
|
||||
"document_version": document_version,
|
||||
})
|
||||
try:
|
||||
import logging as _log
|
||||
_log.info(f"md_to_docx_bytes normalize_html length={len(html)}")
|
||||
except Exception:
|
||||
pass
|
||||
soup = BeautifulSoup(html, "html.parser")
|
||||
doc = Document()
|
||||
sec0 = doc.sections[0]
|
||||
sec0.page_width = Mm(210)
|
||||
sec0.page_height = Mm(297)
|
||||
sec0.left_margin = Mm(15)
|
||||
sec0.right_margin = Mm(15)
|
||||
sec0.top_margin = Mm(20)
|
||||
sec0.bottom_margin = Mm(20)
|
||||
has_cover = bool(cover_src or (soup.find('section', class_='cover') is not None))
|
||||
if has_cover:
|
||||
sec0.left_margin = Mm(0)
|
||||
sec0.right_margin = Mm(0)
|
||||
sec0.top_margin = Mm(0)
|
||||
sec0.bottom_margin = Mm(0)
|
||||
if cover_src:
|
||||
b = _fetch_bytes(cover_src)
|
||||
if b:
|
||||
bio = io.BytesIO(b)
|
||||
doc.add_picture(bio, width=_available_width(sec0))
|
||||
if product_name:
|
||||
p = doc.add_paragraph()
|
||||
r = p.add_run(product_name)
|
||||
r.font.size = Pt(18)
|
||||
r.bold = True
|
||||
t = document_name or None
|
||||
if not t:
|
||||
h1 = soup.body.find('h1') if soup.body else soup.find('h1')
|
||||
t = h1.get_text(strip=True) if h1 else '文档'
|
||||
p2 = doc.add_paragraph()
|
||||
r2 = p2.add_run(t or '文档')
|
||||
r2.font.size = Pt(24)
|
||||
r2.bold = True
|
||||
if filename_text:
|
||||
p3 = doc.add_paragraph()
|
||||
r3 = p3.add_run(filename_text)
|
||||
r3.font.size = Pt(13)
|
||||
meta_parts = []
|
||||
if product_version:
|
||||
meta_parts.append("产品版本：" + product_version)
|
||||
if document_version:
|
||||
meta_parts.append("文档版本：" + document_version)
|
||||
if meta_parts:
|
||||
pm = doc.add_paragraph(" ".join(meta_parts))
|
||||
pm.font = None
|
||||
doc.add_section(WD_SECTION.NEW_PAGE)
|
||||
sec = doc.sections[-1]
|
||||
sec.page_width = Mm(210)
|
||||
sec.page_height = Mm(297)
|
||||
sec.left_margin = Mm(15)
|
||||
sec.right_margin = Mm(15)
|
||||
sec.top_margin = Mm(20)
|
||||
sec.bottom_margin = Mm(20)
|
||||
else:
|
||||
sec = sec0
|
||||
if header_text or logo_url or filename_text:
|
||||
hp = sec.header.add_paragraph()
|
||||
left = header_text or ''
|
||||
right = ''
|
||||
if '||' in left:
|
||||
parts = left.split('||', 1)
|
||||
left, right = parts[0], parts[1]
|
||||
elif '|' in left:
|
||||
parts = left.split('|', 1)
|
||||
left, right = parts[0], parts[1]
|
||||
if left.strip():
|
||||
hp.add_run(left.strip())
|
||||
if right.strip():
|
||||
rp = sec.header.add_paragraph()
|
||||
rp.alignment = WD_PARAGRAPH_ALIGNMENT.RIGHT
|
||||
rp.add_run(right.strip())
|
||||
elif filename_text:
|
||||
rp = sec.header.add_paragraph()
|
||||
rp.alignment = WD_PARAGRAPH_ALIGNMENT.RIGHT
|
||||
rp.add_run(filename_text)
|
||||
if footer_text or copyright_text:
|
||||
fp = sec.footer.add_paragraph()
|
||||
if footer_text:
|
||||
fp.add_run(footer_text)
|
||||
if copyright_text:
|
||||
cp = sec.footer.add_paragraph()
|
||||
cp.add_run(copyright_text)
|
||||
pn = sec.footer.add_paragraph()
|
||||
pn.alignment = WD_PARAGRAPH_ALIGNMENT.RIGHT
|
||||
_add_field(pn, 'PAGE')
|
||||
if toc:
|
||||
doc.add_paragraph('目录')
|
||||
_add_field(doc.add_paragraph(), 'TOC \\o "1-3" \\h \\z \\u')
|
||||
doc.add_page_break()
|
||||
def add_inline(p, node):
|
||||
if isinstance(node, str):
|
||||
p.add_run(node)
|
||||
return
|
||||
if node.name in ['strong', 'b']:
|
||||
r = p.add_run(node.get_text())
|
||||
r.bold = True
|
||||
return
|
||||
if node.name in ['em', 'i']:
|
||||
r = p.add_run(node.get_text())
|
||||
r.italic = True
|
||||
return
|
||||
if node.name == 'code':
|
||||
r = p.add_run(node.get_text())
|
||||
r.font.name = 'Courier New'
|
||||
return
|
||||
if node.name == 'a':
|
||||
text = node.get_text()
|
||||
href = node.get('href')
|
||||
extra = node.get('data-doc')
|
||||
resolved = resolve_link(href, extra)
|
||||
if resolved:
|
||||
p.add_run(text + ' [' + resolved + ']')
|
||||
else:
|
||||
p.add_run(text)
|
||||
return
|
||||
if node.name == 'img':
|
||||
src = node.get('src') or ''
|
||||
b = _fetch_bytes(src)
|
||||
if b:
|
||||
bio = io.BytesIO(b)
|
||||
try:
|
||||
doc.add_picture(bio, width=_available_width(sec))
|
||||
except Exception:
|
||||
pass
|
||||
return
|
||||
for c in getattr(node, 'children', []):
|
||||
add_inline(p, c)
|
||||
def process_block(el):
|
||||
name = getattr(el, 'name', None)
|
||||
if name is None:
|
||||
return
|
||||
cls = el.get('class') or []
|
||||
if name == 'div' and 'doc-meta' in cls:
|
||||
return
|
||||
if name == 'section' and 'cover' in cls:
|
||||
return
|
||||
if name == 'nav' and 'toc' in cls:
|
||||
return
|
||||
if name == 'div':
|
||||
for child in el.children:
|
||||
process_block(child)
|
||||
return
|
||||
if name == 'h1':
|
||||
doc.add_heading(el.get_text(), level=1)
|
||||
return
|
||||
if name == 'h2' or (name == 'strong' and 'subtitle' in cls):
|
||||
doc.add_heading(el.get_text(), level=2)
|
||||
return
|
||||
if name == 'h3':
|
||||
doc.add_heading(el.get_text(), level=3)
|
||||
return
|
||||
if name == 'p':
|
||||
p = doc.add_paragraph()
|
||||
for c in el.children:
|
||||
add_inline(p, c)
|
||||
return
|
||||
if name in ['ul', 'ol']:
|
||||
for li in el.find_all('li', recursive=False):
|
||||
p = doc.add_paragraph(style='List Bullet')
|
||||
for c in li.children:
|
||||
add_inline(p, c)
|
||||
return
|
||||
if name == 'pre':
|
||||
code = el.get_text() or ''
|
||||
p = doc.add_paragraph()
|
||||
run = p.add_run(code)
|
||||
run.font.name = 'Courier New'
|
||||
return
|
||||
if name == 'blockquote':
|
||||
p = doc.add_paragraph(el.get_text())
|
||||
p.paragraph_format.left_indent = Mm(10)
|
||||
return
|
||||
if name == 'table':
|
||||
rows = []
|
||||
thead = el.find('thead')
|
||||
tbody = el.find('tbody')
|
||||
if thead:
|
||||
hdrs = [th.get_text(strip=True) for th in thead.find_all('th')]
|
||||
else:
|
||||
hdrs = [cell.get_text(strip=True) for cell in el.find_all('tr')[0].find_all(['th','td'])] if el.find_all('tr') else []
|
||||
trs = tbody.find_all('tr') if tbody else el.find_all('tr')[1:]
|
||||
for tr in trs:
|
||||
tds = [td.get_text(strip=True) for td in tr.find_all('td')]
|
||||
rows.append(tds)
|
||||
tbl = doc.add_table(rows=1 + len(rows), cols=len(hdrs) or 1)
|
||||
hdr = tbl.rows[0].cells
|
||||
for k, h in enumerate(hdrs or ['']):
|
||||
hdr[k].text = h
|
||||
for r_idx, row in enumerate(rows):
|
||||
cells = tbl.rows[1 + r_idx].cells
|
||||
for c_idx in range(len(hdrs) or 1):
|
||||
cells[c_idx].text = (row[c_idx] if c_idx < len(row) else '')
|
||||
return
|
||||
if name == 'img':
|
||||
src = el.get('src') or ''
|
||||
b = _fetch_bytes(src)
|
||||
if b:
|
||||
bio = io.BytesIO(b)
|
||||
try:
|
||||
doc.add_picture(bio, width=_available_width(sec))
|
||||
except Exception:
|
||||
pass
|
||||
return
|
||||
body = soup.body or soup
|
||||
for el in body.children:
|
||||
process_block(el)
|
||||
bio = io.BytesIO()
|
||||
try:
|
||||
import logging as _log
|
||||
_log.info("md_to_docx_bytes saving doc")
|
||||
except Exception:
|
||||
pass
|
||||
doc.save(bio)
|
||||
try:
|
||||
import logging as _log
|
||||
_log.info(f"md_to_docx_bytes done size={bio.tell()}")
|
||||
except Exception:
|
||||
pass
|
||||
return bio.getvalue()
|
||||
|
||||
def md_to_pdf_bytes(md: str) -> bytes:
|
||||
return md_to_pdf_bytes_with_renderer(md, renderer="weasyprint")
|
||||
|
||||
def _md_with_tables_to_html(md_text: str) -> str:
|
||||
lines = md_text.splitlines()
|
||||
out = []
|
||||
i = 0
|
||||
while i < len(lines):
|
||||
line = lines[i]
|
||||
def is_sep(s: str) -> bool:
|
||||
s = s.strip()
|
||||
if "|" not in s:
|
||||
return False
|
||||
s = s.strip("|")
|
||||
return all(set(seg.strip()) <= set("-: ") and len(seg.strip()) >= 1 for seg in s.split("|"))
|
||||
if "|" in line and i + 1 < len(lines) and is_sep(lines[i + 1]):
|
||||
headers = [c.strip() for c in line.strip().strip("|").split("|")]
|
||||
j = i + 2
|
||||
rows = []
|
||||
while j < len(lines) and "|" in lines[j]:
|
||||
rows.append([c.strip() for c in lines[j].strip().strip("|").split("|")])
|
||||
j += 1
|
||||
tbl = ["<table>", "<thead><tr>"]
|
||||
for h in headers:
|
||||
tbl.append(f"<th>{h}</th>")
|
||||
tbl.append("</tr></thead><tbody>")
|
||||
for row in rows:
|
||||
tbl.append("<tr>")
|
||||
for idx in range(len(headers)):
|
||||
cell = row[idx] if idx < len(row) else ""
|
||||
tbl.append(f"<td>{cell}</td>")
|
||||
tbl.append("</tr>")
|
||||
tbl.append("</tbody></table>")
|
||||
out.append("".join(tbl))
|
||||
i = j
|
||||
continue
|
||||
out.append(line)
|
||||
i += 1
|
||||
return marko.convert("\n".join(out))
|
||||
|
||||
def _render_markdown_html(md_text: str) -> str:
|
||||
if _HAS_MD_IT and _mdit is not None:
|
||||
try:
|
||||
md = _mdit.MarkdownIt("commonmark").enable(["table", "strikethrough"])
|
||||
if _tasklists_plugin:
|
||||
md.use(_tasklists_plugin)
|
||||
if _deflist_plugin:
|
||||
md.use(_deflist_plugin)
|
||||
if _footnote_plugin:
|
||||
md.use(_footnote_plugin)
|
||||
if _attrs_plugin:
|
||||
md.use(_attrs_plugin)
|
||||
return md.render(md_text)
|
||||
except Exception:
|
||||
pass
|
||||
return _md_with_tables_to_html(md_text)
|
||||
|
||||
def normalize_html(md_or_html: str, options: Optional[Dict[str, Optional[str]]] = None) -> str:
|
||||
html = _render_markdown_html(md_or_html)
|
||||
soup = BeautifulSoup(html, "html.parser")
|
||||
for s in soup.find_all("strong", class_="subtitle"):
|
||||
s.name = "h2"
|
||||
s.attrs = {"data-origin": "subtitle"}
|
||||
for a in soup.find_all("a"):
|
||||
href_val = a.get("href")
|
||||
extra_val = a.get("data-doc")
|
||||
href = href_val if isinstance(href_val, str) else None
|
||||
extra = extra_val if isinstance(extra_val, str) else None
|
||||
resolved = resolve_link(href, extra)
|
||||
if resolved:
|
||||
a["href"] = resolved
|
||||
elif not href and extra:
|
||||
a.replace_with(a.get_text() + " [" + extra + "]")
|
||||
opts = options or {}
|
||||
header_text = opts.get("header_text") or None
|
||||
footer_text = opts.get("footer_text") or None
|
||||
logo_url = opts.get("logo_url") or None
|
||||
copyright_text = opts.get("copyright_text") or None
|
||||
cover_src = opts.get("cover_src") or None
|
||||
product_name_opt = opts.get("product_name") or None
|
||||
document_name_opt = opts.get("document_name") or None
|
||||
product_version_opt = opts.get("product_version") or None
|
||||
document_version_opt = opts.get("document_version") or None
|
||||
toc_flag = bool(opts.get("toc"))
|
||||
meta = soup.new_tag("div", attrs={"class": "doc-meta"})
|
||||
if header_text:
|
||||
ht = soup.new_tag("div", attrs={"class": "doc-header-text"})
|
||||
text = header_text
|
||||
left = text
|
||||
right = ""
|
||||
if "||" in text:
|
||||
parts = text.split("||", 1)
|
||||
left, right = parts[0], parts[1]
|
||||
elif "|" in text:
|
||||
parts = text.split("|", 1)
|
||||
left, right = parts[0], parts[1]
|
||||
if logo_url:
|
||||
img = soup.new_tag("img", attrs={"class": "logo-inline", "src": logo_url})
|
||||
ht.append(img)
|
||||
hl = soup.new_tag("span", attrs={"class": "doc-header-left"})
|
||||
hl.string = left
|
||||
ht.append(hl)
|
||||
if right.strip():
|
||||
hr = soup.new_tag("span", attrs={"class": "doc-header-right"})
|
||||
hr.string = right
|
||||
ht.append(hr)
|
||||
meta.append(ht)
|
||||
else:
|
||||
first_h1 = None
|
||||
if soup.body:
|
||||
first_h1 = soup.body.find("h1")
|
||||
else:
|
||||
first_h1 = soup.find("h1")
|
||||
left = (first_h1.get_text(strip=True) if first_h1 else "文档")
|
||||
right = opts.get("filename_text") or ""
|
||||
ht = soup.new_tag("div", attrs={"class": "doc-header-text"})
|
||||
if logo_url:
|
||||
img = soup.new_tag("img", attrs={"class": "logo-inline", "src": logo_url})
|
||||
ht.append(img)
|
||||
hl = soup.new_tag("span", attrs={"class": "doc-header-left"})
|
||||
hl.string = left
|
||||
ht.append(hl)
|
||||
if right:
|
||||
hr = soup.new_tag("span", attrs={"class": "doc-header-right"})
|
||||
hr.string = right
|
||||
ht.append(hr)
|
||||
meta.append(ht)
|
||||
if footer_text:
|
||||
ft = soup.new_tag("div", attrs={"class": "doc-footer-text"})
|
||||
ft.string = footer_text
|
||||
meta.append(ft)
|
||||
page_header_val = (header_text or (document_name_opt or None))
|
||||
if not page_header_val:
|
||||
first_h1_for_header = None
|
||||
if soup.body:
|
||||
first_h1_for_header = soup.body.find("h1")
|
||||
else:
|
||||
first_h1_for_header = soup.find("h1")
|
||||
page_header_val = (first_h1_for_header.get_text(strip=True) if first_h1_for_header else "文档")
|
||||
page_footer_val = (footer_text or "FunMD")
|
||||
ph = soup.new_tag("div", attrs={"class": "doc-page-header"})
|
||||
if logo_url:
|
||||
logo_inline = soup.new_tag("img", attrs={"src": logo_url, "class": "doc-page-header-logo"})
|
||||
ph.append(logo_inline)
|
||||
ht_inline = soup.new_tag("span", attrs={"class": "doc-page-header-text"})
|
||||
ht_inline.string = page_header_val
|
||||
ph.append(ht_inline)
|
||||
meta.append(ph)
|
||||
pf = soup.new_tag("div", attrs={"class": "doc-page-footer"})
|
||||
pf.string = page_footer_val
|
||||
meta.append(pf)
|
||||
if copyright_text:
|
||||
cp = soup.new_tag("div", attrs={"class": "doc-copyright"})
|
||||
cp.string = copyright_text
|
||||
meta.append(cp)
|
||||
# brand logo is rendered inline within header; no separate top-left element
|
||||
if soup.body:
|
||||
soup.body.insert(0, meta)
|
||||
else:
|
||||
soup.insert(0, meta)
|
||||
if not soup.head:
|
||||
head = soup.new_tag("head")
|
||||
soup.insert(0, head)
|
||||
else:
|
||||
head = soup.head
|
||||
style_run = soup.new_tag("style")
|
||||
style_run.string = "@page{margin:20mm}@page{\n @top-center{content: element(page-header)}\n @bottom-center{content: element(page-footer)}\n}\n.doc-page-header{position: running(page-header); font-size:10pt; color:#666; display:block; text-align:center; width:100%}\n.doc-page-header::after{content:''; display:block; width:80%; border-bottom:1px solid #d9d9d9; margin:4px auto 0}\n.doc-page-header-logo{height:20px; vertical-align:middle; margin-right:4px}\n.doc-page-header-text{vertical-align:middle}\n.doc-page-footer{position: running(page-footer); font-size:10pt; color:#666}\n.doc-page-footer::before{content:''; display:block; width:80%; border-top:1px solid #d9d9d9; margin:0 auto 4px}"
|
||||
head.append(style_run)
|
||||
# Fallback inline styles for cover to ensure visibility even if external CSS isn't loaded
|
||||
if (cover_src or product_name_opt or document_name_opt or product_version_opt or document_version_opt):
|
||||
if not soup.head:
|
||||
head = soup.new_tag("head")
|
||||
soup.insert(0, head)
|
||||
else:
|
||||
head = soup.head
|
||||
style = soup.new_tag("style")
|
||||
style.string = "@page:first{margin:0} html,body{margin:0;padding:0}.cover{position:relative;width:210mm;height:297mm;overflow:hidden;page-break-after:always}.cover .cover-bg{position:absolute;left:0;top:0;right:0;bottom:0;width:100%;height:100%;object-fit:cover;display:block}.cover .cover-brand{position:absolute;top:20mm;left:20mm;font-size:18pt;font-weight:700;color:#1d4ed8}.cover .cover-footer{position:absolute;left:0;right:0;bottom:0;background:#1d4ed8;color:#fff;padding:12mm 20mm}.cover .cover-title{font-size:24pt;font-weight:700;margin:0}.cover .cover-subtitle{font-size:13pt;margin-top:4pt}.cover .cover-meta{margin-top:8pt;font-size:11pt;display:flex;gap:20mm}"
|
||||
head.append(style)
|
||||
if cover_src or product_name_opt or document_name_opt or product_version_opt or document_version_opt:
|
||||
cov = soup.new_tag("section", attrs={"class": "cover"})
|
||||
if cover_src:
|
||||
bg = soup.new_tag("img", attrs={"class": "cover-bg", "src": cover_src})
|
||||
cov.append(bg)
|
||||
if product_name_opt:
|
||||
brand_el = soup.new_tag("div", attrs={"class": "cover-brand"})
|
||||
brand_el.string = product_name_opt
|
||||
cov.append(brand_el)
|
||||
footer = soup.new_tag("div", attrs={"class": "cover-footer"})
|
||||
title_text = document_name_opt or None
|
||||
if not title_text:
|
||||
first_h1 = soup.body.find("h1") if soup.body else soup.find("h1")
|
||||
if first_h1:
|
||||
title_text = first_h1.get_text(strip=True)
|
||||
title_el = soup.new_tag("div", attrs={"class": "cover-title"})
|
||||
title_el.string = title_text or "文档"
|
||||
footer.append(title_el)
|
||||
subtitle_val = opts.get("filename_text") or ""
|
||||
if subtitle_val:
|
||||
subtitle_el = soup.new_tag("div", attrs={"class": "cover-subtitle"})
|
||||
subtitle_el.string = subtitle_val
|
||||
footer.append(subtitle_el)
|
||||
meta_el = soup.new_tag("div", attrs={"class": "cover-meta"})
|
||||
if product_version_opt:
|
||||
pv = soup.new_tag("span")
|
||||
pv.string = f"产品版本：{product_version_opt}"
|
||||
meta_el.append(pv)
|
||||
if document_version_opt:
|
||||
dv = soup.new_tag("span")
|
||||
dv.string = f"文档版本：{document_version_opt}"
|
||||
meta_el.append(dv)
|
||||
footer.append(meta_el)
|
||||
cov.append(footer)
|
||||
if soup.body:
|
||||
soup.body.insert(1, cov)
|
||||
else:
|
||||
soup.insert(1, cov)
|
||||
if toc_flag:
|
||||
headings = [
|
||||
el for el in (soup.find_all(["h1", "h2", "h3"]) or [])
|
||||
if el.get("data-origin") != "subtitle"
|
||||
]
|
||||
if headings:
|
||||
ul = soup.new_tag("ul")
|
||||
idx = 1
|
||||
for el in headings:
|
||||
text = el.get_text(strip=True)
|
||||
if not text:
|
||||
continue
|
||||
hid = el.get("id")
|
||||
if not hid:
|
||||
hid = f"sec-{idx}"
|
||||
el["id"] = hid
|
||||
idx += 1
|
||||
li = soup.new_tag("li", attrs={"class": f"toc-{el.name}"})
|
||||
a = soup.new_tag("a", attrs={"href": f"#{hid}", "class": "toc-text"})
|
||||
a.string = text
|
||||
dots = soup.new_tag("span", attrs={"class": "toc-dots"})
|
||||
page = soup.new_tag("span", attrs={"class": "toc-page", "data-target": f"#{hid}"})
|
||||
li.append(a)
|
||||
li.append(dots)
|
||||
li.append(page)
|
||||
ul.append(li)
|
||||
nav = soup.new_tag("nav", attrs={"class": "toc"})
|
||||
h = soup.new_tag("h1")
|
||||
h.string = "目录"
|
||||
nav.append(h)
|
||||
nav.append(ul)
|
||||
if soup.body:
|
||||
soup.body.insert(2, nav)
|
||||
else:
|
||||
soup.insert(2, nav)
|
||||
if soup.body:
|
||||
for h in soup.body.find_all(["h1", "h2", "h3"]):
|
||||
sib: Optional[PageElement] = h.find_next_sibling()
|
||||
blocks: List[Any] = []
|
||||
first_table: Optional[Any] = None
|
||||
while sib is not None:
|
||||
# Skip pure whitespace nodes
|
||||
if getattr(sib, "name", None) is None:
|
||||
try:
|
||||
if str(sib).strip() == "":
|
||||
sib = sib.next_sibling
|
||||
continue
|
||||
except Exception:
|
||||
break
|
||||
# Stop if next heading encountered
|
||||
name = getattr(sib, "name", None)
|
||||
if name in ["h1", "h2", "h3"]:
|
||||
break
|
||||
# Collect explanatory blocks until first table
|
||||
if name == "table":
|
||||
first_table = sib
|
||||
break
|
||||
if name in ["p", "blockquote", "ul", "ol"]:
|
||||
blocks.append(sib)
|
||||
sib = sib.next_sibling
|
||||
continue
|
||||
# Unknown block: stop grouping to avoid wrapping unrelated content
|
||||
break
|
||||
if first_table is not None:
|
||||
wrap = soup.new_tag("div", attrs={"class": "table-block"})
|
||||
h.insert_before(wrap)
|
||||
wrap.append(h.extract())
|
||||
for el in blocks:
|
||||
wrap.append(el.extract())
|
||||
wrap.append(first_table.extract())
|
||||
return str(soup)
|
||||
|
||||
def _stylesheets_for(css_name: Optional[str], css_text: Optional[str]):
|
||||
sheets: List[Any] = []
|
||||
if CSS is None:
|
||||
return sheets
|
||||
if css_text:
|
||||
sheets.append(CSS(string=css_text))
|
||||
if css_name:
|
||||
css_path = Path(__file__).resolve().parent.parent / "configs" / "styles" / f"{css_name}.css"
|
||||
if css_path.exists():
|
||||
sheets.append(CSS(filename=str(css_path)))
|
||||
return sheets
|
||||
|
||||
def md_to_pdf_bytes_with_renderer(md: str, renderer: str = "weasyprint", css_name: Optional[str] = None, css_text: Optional[str] = None, toc: bool = False, header_text: Optional[str] = None, footer_text: Optional[str] = None, logo_url: Optional[str] = None, copyright_text: Optional[str] = None, filename_text: Optional[str] = None, cover_src: Optional[str] = None, product_name: Optional[str] = None, document_name: Optional[str] = None, product_version: Optional[str] = None, document_version: Optional[str] = None) -> bytes:
|
||||
html = normalize_html(md, options={
|
||||
"toc": "1" if toc else "",
|
||||
"header_text": header_text,
|
||||
"footer_text": footer_text,
|
||||
"logo_url": logo_url,
|
||||
"copyright_text": copyright_text,
|
||||
"filename_text": filename_text,
|
||||
"cover_src": cover_src,
|
||||
"product_name": product_name,
|
||||
"document_name": document_name,
|
||||
"product_version": product_version,
|
||||
"document_version": document_version,
|
||||
})
|
||||
if HTML is not None:
|
||||
stylesheets = _stylesheets_for(css_name, css_text)
|
||||
pdf_bytes = HTML(string=html).write_pdf(stylesheets=stylesheets or None)
|
||||
return pdf_bytes
|
||||
raise RuntimeError("WeasyPrint is not available")
|
||||
Reference in New Issue
Block a user