331 lines
12 KiB
Python
331 lines
12 KiB
Python
#!/usr/bin/env python3
|
|
"""PPTX 文件解析模块，提供三种解析方法。"""
|
|
|
|
import re
|
|
import xml.etree.ElementTree as ET
|
|
import zipfile
|
|
from typing import Any, List, Optional, Tuple
|
|
|
|
from common import (
|
|
_unstructured_elements_to_markdown,
|
|
build_markdown_table,
|
|
flush_list_stack,
|
|
parse_with_docling,
|
|
parse_with_markitdown,
|
|
)
|
|
|
|
|
|
def parse_pptx_with_docling(file_path: str) -> Tuple[Optional[str], Optional[str]]:
|
|
"""使用 docling 库解析 PPTX 文件"""
|
|
return parse_with_docling(file_path)
|
|
|
|
|
|
def parse_pptx_with_unstructured(file_path: str) -> Tuple[Optional[str], Optional[str]]:
|
|
"""使用 unstructured 库解析 PPTX 文件"""
|
|
try:
|
|
from unstructured.partition.pptx import partition_pptx
|
|
except ImportError:
|
|
return None, "unstructured 库未安装"
|
|
|
|
try:
|
|
elements = partition_pptx(
|
|
filename=file_path, infer_table_structure=True, include_metadata=True
|
|
)
|
|
content = _unstructured_elements_to_markdown(elements)
|
|
if not content.strip():
|
|
return None, "文档为空"
|
|
return content, None
|
|
except Exception as e:
|
|
return None, f"unstructured 解析失败: {str(e)}"
|
|
|
|
|
|
def parse_pptx_with_markitdown(file_path: str) -> Tuple[Optional[str], Optional[str]]:
|
|
"""使用 MarkItDown 库解析 PPTX 文件"""
|
|
return parse_with_markitdown(file_path)
|
|
|
|
|
|
def extract_formatted_text_pptx(runs: List[Any]) -> str:
|
|
"""从 PPTX 文本运行中提取带有格式的文本"""
|
|
result = []
|
|
for run in runs:
|
|
if not run.text:
|
|
continue
|
|
|
|
text = run.text
|
|
|
|
font = run.font
|
|
is_bold = getattr(font, "bold", False) or False
|
|
is_italic = getattr(font, "italic", False) or False
|
|
|
|
if is_bold and is_italic:
|
|
text = f"***{text}***"
|
|
elif is_bold:
|
|
text = f"**{text}**"
|
|
elif is_italic:
|
|
text = f"*{text}*"
|
|
|
|
result.append(text)
|
|
|
|
return "".join(result).strip()
|
|
|
|
|
|
def convert_table_to_md_pptx(table: Any) -> str:
|
|
"""将 PPTX 表格转换为 Markdown 格式"""
|
|
rows_data = []
|
|
for row in table.rows:
|
|
row_data = []
|
|
for cell in row.cells:
|
|
cell_content = []
|
|
for para in cell.text_frame.paragraphs:
|
|
text = extract_formatted_text_pptx(para.runs)
|
|
if text:
|
|
cell_content.append(text)
|
|
cell_text = " ".join(cell_content).strip()
|
|
row_data.append(cell_text if cell_text else "")
|
|
rows_data.append(row_data)
|
|
return build_markdown_table(rows_data)
|
|
|
|
|
|
def parse_pptx_with_python_pptx(file_path: str) -> Tuple[Optional[str], Optional[str]]:
|
|
"""使用 python-pptx 库解析 PPTX 文件"""
|
|
try:
|
|
from pptx import Presentation
|
|
from pptx.enum.shapes import MSO_SHAPE_TYPE
|
|
except ImportError:
|
|
return None, "python-pptx 库未安装"
|
|
|
|
_A_NS = {"a": "http://schemas.openxmlformats.org/drawingml/2006/main"}
|
|
|
|
try:
|
|
prs = Presentation(file_path)
|
|
md_content = []
|
|
|
|
for slide_num, slide in enumerate(prs.slides, 1):
|
|
md_content.append(f"\n## Slide {slide_num}\n")
|
|
|
|
list_stack = []
|
|
|
|
for shape in slide.shapes:
|
|
if shape.shape_type == MSO_SHAPE_TYPE.PICTURE:
|
|
continue
|
|
|
|
if hasattr(shape, "has_table") and shape.has_table:
|
|
if list_stack:
|
|
flush_list_stack(list_stack, md_content)
|
|
|
|
table_md = convert_table_to_md_pptx(shape.table)
|
|
md_content.append(table_md)
|
|
|
|
if hasattr(shape, "text_frame"):
|
|
for para in shape.text_frame.paragraphs:
|
|
pPr = para._element.pPr
|
|
is_list = False
|
|
if pPr is not None:
|
|
is_list = (
|
|
para.level > 0
|
|
or pPr.find(".//a:buChar", namespaces=_A_NS) is not None
|
|
or pPr.find(".//a:buAutoNum", namespaces=_A_NS) is not None
|
|
)
|
|
|
|
if is_list:
|
|
level = para.level
|
|
|
|
while len(list_stack) <= level:
|
|
list_stack.append("")
|
|
|
|
text = extract_formatted_text_pptx(para.runs)
|
|
if text:
|
|
is_ordered = (
|
|
pPr is not None
|
|
and pPr.find(".//a:buAutoNum", namespaces=_A_NS) is not None
|
|
)
|
|
marker = "1. " if is_ordered else "- "
|
|
indent = " " * level
|
|
list_stack[level] = f"{indent}{marker}{text}"
|
|
|
|
for i in range(len(list_stack)):
|
|
if list_stack[i]:
|
|
md_content.append(list_stack[i] + "\n")
|
|
list_stack[i] = ""
|
|
else:
|
|
if list_stack:
|
|
flush_list_stack(list_stack, md_content)
|
|
|
|
text = extract_formatted_text_pptx(para.runs)
|
|
if text:
|
|
md_content.append(f"{text}\n")
|
|
|
|
if list_stack:
|
|
flush_list_stack(list_stack, md_content)
|
|
|
|
md_content.append("---\n")
|
|
|
|
content = "\n".join(md_content)
|
|
if not content.strip():
|
|
return None, "文档为空"
|
|
return content, None
|
|
except Exception as e:
|
|
return None, f"python-pptx 解析失败: {str(e)}"
|
|
|
|
|
|
def parse_pptx_with_xml(file_path: str) -> Tuple[Optional[str], Optional[str]]:
|
|
"""使用 XML 原生解析 PPTX 文件"""
|
|
pptx_namespace = {
|
|
"a": "http://schemas.openxmlformats.org/drawingml/2006/main",
|
|
"p": "http://schemas.openxmlformats.org/presentationml/2006/main",
|
|
"r": "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
|
|
}
|
|
|
|
def extract_text_with_formatting_xml(text_elem: Any, namespaces: dict) -> str:
|
|
result = []
|
|
runs = text_elem.findall(".//a:r", namespaces=namespaces)
|
|
for run in runs:
|
|
t_elem = run.find(".//a:t", namespaces=namespaces)
|
|
if t_elem is None or not t_elem.text:
|
|
continue
|
|
|
|
text = t_elem.text
|
|
|
|
rPr = run.find(".//a:rPr", namespaces=namespaces)
|
|
is_bold = False
|
|
is_italic = False
|
|
|
|
if rPr is not None:
|
|
is_bold = rPr.find(".//a:b", namespaces=namespaces) is not None
|
|
is_italic = rPr.find(".//a:i", namespaces=namespaces) is not None
|
|
|
|
if is_bold and is_italic:
|
|
text = f"***{text}***"
|
|
elif is_bold:
|
|
text = f"**{text}**"
|
|
elif is_italic:
|
|
text = f"*{text}*"
|
|
|
|
result.append(text)
|
|
|
|
return "".join(result).strip() if result else ""
|
|
|
|
def convert_table_to_md_xml(table_elem: Any, namespaces: dict) -> str:
|
|
rows = table_elem.findall(".//a:tr", namespaces=namespaces)
|
|
if not rows:
|
|
return ""
|
|
|
|
rows_data = []
|
|
for row in rows:
|
|
cells = row.findall(".//a:tc", namespaces=namespaces)
|
|
row_data = []
|
|
for cell in cells:
|
|
cell_text = extract_text_with_formatting_xml(cell, namespaces)
|
|
if cell_text:
|
|
cell_text = cell_text.replace("\n", " ").replace("\r", "")
|
|
row_data.append(cell_text if cell_text else "")
|
|
rows_data.append(row_data)
|
|
return build_markdown_table(rows_data)
|
|
|
|
def is_list_item_xml(p_elem: Any, namespaces: dict) -> Tuple[bool, bool]:
|
|
if p_elem is None:
|
|
return False, False
|
|
|
|
pPr = p_elem.find(".//a:pPr", namespaces=namespaces)
|
|
if pPr is None:
|
|
return False, False
|
|
|
|
buChar = pPr.find(".//a:buChar", namespaces=namespaces)
|
|
if buChar is not None:
|
|
return True, False
|
|
|
|
buAutoNum = pPr.find(".//a:buAutoNum", namespaces=namespaces)
|
|
if buAutoNum is not None:
|
|
return True, True
|
|
|
|
return False, False
|
|
|
|
def get_indent_level_xml(p_elem: Any, namespaces: dict) -> int:
|
|
if p_elem is None:
|
|
return 0
|
|
|
|
pPr = p_elem.find(".//a:pPr", namespaces=namespaces)
|
|
if pPr is None:
|
|
return 0
|
|
|
|
lvl = pPr.get("lvl")
|
|
return int(lvl) if lvl else 0
|
|
|
|
try:
|
|
md_content = []
|
|
|
|
with zipfile.ZipFile(file_path) as zip_file:
|
|
slide_files = [
|
|
f
|
|
for f in zip_file.namelist()
|
|
if re.match(r"ppt/slides/slide\d+\.xml$", f)
|
|
]
|
|
slide_files.sort(
|
|
key=lambda f: int(re.search(r"slide(\d+)\.xml$", f).group(1))
|
|
)
|
|
|
|
for slide_idx, slide_file in enumerate(slide_files, 1):
|
|
md_content.append("\n## Slide {}\n".format(slide_idx))
|
|
|
|
with zip_file.open(slide_file) as slide_xml:
|
|
slide_root = ET.parse(slide_xml).getroot()
|
|
|
|
tx_bodies = slide_root.findall(
|
|
".//p:sp/p:txBody", namespaces=pptx_namespace
|
|
)
|
|
|
|
tables = slide_root.findall(".//a:tbl", namespaces=pptx_namespace)
|
|
for table in tables:
|
|
table_md = convert_table_to_md_xml(table, pptx_namespace)
|
|
if table_md:
|
|
md_content.append(table_md)
|
|
|
|
for tx_body in tx_bodies:
|
|
paragraphs = tx_body.findall(
|
|
".//a:p", namespaces=pptx_namespace
|
|
)
|
|
list_stack = []
|
|
|
|
for para in paragraphs:
|
|
is_list, is_ordered = is_list_item_xml(para, pptx_namespace)
|
|
|
|
if is_list:
|
|
level = get_indent_level_xml(para, pptx_namespace)
|
|
|
|
while len(list_stack) <= level:
|
|
list_stack.append("")
|
|
|
|
text = extract_text_with_formatting_xml(
|
|
para, pptx_namespace
|
|
)
|
|
if text:
|
|
marker = "1. " if is_ordered else "- "
|
|
indent = " " * level
|
|
list_stack[level] = f"{indent}{marker}{text}"
|
|
|
|
for i in range(len(list_stack)):
|
|
if list_stack[i]:
|
|
md_content.append(list_stack[i] + "\n")
|
|
list_stack[i] = ""
|
|
else:
|
|
if list_stack:
|
|
flush_list_stack(list_stack, md_content)
|
|
|
|
text = extract_text_with_formatting_xml(
|
|
para, pptx_namespace
|
|
)
|
|
if text:
|
|
md_content.append(f"{text}\n")
|
|
|
|
if list_stack:
|
|
flush_list_stack(list_stack, md_content)
|
|
|
|
md_content.append("---\n")
|
|
|
|
content = "\n".join(md_content)
|
|
if not content.strip():
|
|
return None, "文档为空"
|
|
return content, None
|
|
except Exception as e:
|
|
return None, f"XML 解析失败: {str(e)}"
|