257 lines
8.4 KiB
Python
257 lines
8.4 KiB
Python
#!/usr/bin/env python3
|
||
"""Convert textutil Word HTML export to ct-word-doc seed JS module."""
|
||
|
||
import argparse
|
||
import json
|
||
import re
|
||
import subprocess
|
||
import tempfile
|
||
from pathlib import Path
|
||
from typing import Dict, List, Optional, Set
|
||
|
||
from bs4 import BeautifulSoup, NavigableString, Tag
|
||
|
||
DEFAULT_SEMANTIC = {
|
||
"p1": "ct-word-title",
|
||
"p2": "ct-word-contract-no",
|
||
"p3": "ct-word-contract-no",
|
||
"p5": "ct-word-party-line",
|
||
"p6": "ct-word-party-line",
|
||
"p7": "ct-word-party-line",
|
||
"p8": "ct-word-party-line",
|
||
}
|
||
|
||
|
||
def parse_css_rules(css_text: str) -> Dict[str, str]:
|
||
rules: Dict[str, str] = {}
|
||
for block in re.findall(r"([^{]+)\{([^}]+)\}", css_text):
|
||
selector = block[0].strip()
|
||
props = block[1].strip()
|
||
if "," in selector:
|
||
continue
|
||
selector = selector.lstrip(".")
|
||
if re.match(r"^(p|span|td|table)\.", selector):
|
||
rules[selector] = props
|
||
return rules
|
||
|
||
|
||
def is_red_style(style: str) -> bool:
|
||
return bool(re.search(r"color\s*:\s*#ff0000", style, re.I))
|
||
|
||
|
||
def build_red_classes(rules: Dict[str, str]) -> Set[str]:
|
||
red = set()
|
||
for cls, props in rules.items():
|
||
if is_red_style(props):
|
||
red.add(cls.split(".")[-1])
|
||
return red
|
||
|
||
|
||
def class_list(tag: Tag) -> List[str]:
|
||
raw = tag.get("class") or []
|
||
if isinstance(raw, str):
|
||
return raw.split()
|
||
return list(raw)
|
||
|
||
|
||
def primary_class(tag: Tag) -> Optional[str]:
|
||
classes = class_list(tag)
|
||
for c in classes:
|
||
if c in DEFAULT_SEMANTIC or re.match(r"^[pst]\d+$", c) or re.match(r"^td\d+$", c):
|
||
return c
|
||
return classes[0] if classes else None
|
||
|
||
|
||
def merge_style(tag: Tag, rules: Dict[str, str]) -> None:
|
||
parts: List[str] = []
|
||
for c in class_list(tag):
|
||
key_p = f"p.{c}" if c.startswith("p") else None
|
||
key_s = f"span.{c}" if c.startswith("s") else None
|
||
key_td = f"td.{c}" if c.startswith("td") else None
|
||
key_t = f"table.{c}" if c.startswith("t") else None
|
||
for key in (key_p, key_s, key_td, key_t):
|
||
if key and key in rules:
|
||
parts.append(rules[key])
|
||
if parts:
|
||
existing = tag.get("style", "")
|
||
merged = ";".join([existing] + parts) if existing else ";".join(parts)
|
||
tag["style"] = merged
|
||
|
||
|
||
def strip_apple_noise(soup: BeautifulSoup) -> None:
|
||
for el in soup.find_all(class_="Apple-converted-space"):
|
||
el.replace_with("\u00a0" * max(1, len(el.get_text())))
|
||
for el in soup.find_all(class_="Apple-tab-span"):
|
||
el.replace_with("\t")
|
||
|
||
|
||
def wrap_risk_redlines(soup: BeautifulSoup, red_classes: Set[str]) -> None:
|
||
risk_seq = 0
|
||
|
||
def next_id() -> str:
|
||
nonlocal risk_seq
|
||
risk_seq += 1
|
||
return f"risk-{risk_seq}"
|
||
|
||
def is_red_tag(tag: Tag) -> bool:
|
||
pc = primary_class(tag)
|
||
return pc in red_classes if pc else False
|
||
|
||
for p in list(soup.find_all("p")):
|
||
if not is_red_tag(p):
|
||
continue
|
||
if p.find_parent(class_=lambda x: x and "ct-risk-redline" in x):
|
||
continue
|
||
inner = list(p.contents)
|
||
if not inner:
|
||
continue
|
||
wrapper = soup.new_tag(
|
||
"span",
|
||
attrs={
|
||
"class": "ct-risk-redline",
|
||
"data-risk-redline": "1",
|
||
"data-risk-id": next_id(),
|
||
},
|
||
)
|
||
for child in inner:
|
||
wrapper.append(child.extract() if isinstance(child, Tag) else child)
|
||
p.clear()
|
||
p.append(wrapper)
|
||
|
||
for span in list(soup.find_all("span")):
|
||
if not is_red_tag(span):
|
||
continue
|
||
if span.find_parent(class_=lambda x: x and "ct-risk-redline" in x):
|
||
continue
|
||
parent_p = span.find_parent("p")
|
||
if parent_p and is_red_tag(parent_p):
|
||
continue
|
||
wrapper = soup.new_tag(
|
||
"span",
|
||
attrs={
|
||
"class": "ct-risk-redline",
|
||
"data-risk-redline": "1",
|
||
"data-risk-id": next_id(),
|
||
},
|
||
)
|
||
span.wrap(wrapper)
|
||
|
||
|
||
def apply_semantic_classes(root: Tag, semantic: Dict[str, str]) -> None:
|
||
for tag in root.find_all(True):
|
||
pc = primary_class(tag)
|
||
if pc and pc in semantic:
|
||
classes = class_list(tag)
|
||
extra = semantic[pc]
|
||
if extra not in classes:
|
||
tag["class"] = classes + [extra]
|
||
|
||
|
||
def map_tables(root: Tag) -> None:
|
||
for i, table in enumerate(root.find_all("table")):
|
||
classes = class_list(table)
|
||
if "ct-word-table" not in classes:
|
||
table["class"] = classes + ["ct-doc-table", "ct-word-table"]
|
||
for td in table.find_all("td"):
|
||
td["class"] = class_list(td) + ["ct-word-td"]
|
||
|
||
|
||
def apply_template_vars(html: str) -> str:
|
||
regex_replacements = [
|
||
(r"合同编号<span[^>]*>：</span>【LNZLHT\s*<span[^>]*>[\s\S]*?</span>\s*】",
|
||
"合同编号：【LNZLHT {{contractCode}} 】"),
|
||
(r"合同编号：【LNZLHT[^】]*】", "合同编号：【LNZLHT {{contractCode}} 】"),
|
||
(r"协议编号：【LNZLHT[^】]*】", "协议编号：【LNZLHT {{contractCode}} 】"),
|
||
]
|
||
literal_replacements = [
|
||
("甲方（出租方）：羚牛氢能科技（广东）有限公司", "甲方（出租方）：{{lessorName}}"),
|
||
("甲方(出租方): 羚牛氢能科技（广东）有限公司", "甲方(出租方): {{lessorName}}"),
|
||
("甲方：羚牛氢能科技（广东）有限公司", "甲方：{{lessorName}}"),
|
||
("致：羚牛氢能科技（广东）有限公司", "致：{{lessorName}}"),
|
||
("甲方（车辆提供方）：", "甲方（车辆提供方）：{{lessorName}}"),
|
||
("乙方（车辆使用方）：", "乙方（车辆使用方）：{{customerName}}"),
|
||
("乙方(承租方):</b>", "乙方(承租方): {{customerName}}</b>"),
|
||
("乙方（承租方）：</b>", "乙方（承租方）：{{customerName}}</b>"),
|
||
]
|
||
out = html
|
||
for pattern, repl in regex_replacements:
|
||
out = re.sub(pattern, repl, out)
|
||
for old, new in literal_replacements:
|
||
out = out.replace(old, new)
|
||
return out
|
||
|
||
|
||
def scope_css(css_text: str) -> str:
|
||
scoped = []
|
||
for block in re.findall(r"([^{]+)\{([^}]+)\}", css_text):
|
||
selector = block[0].strip()
|
||
props = block[1].strip()
|
||
if selector.startswith("@") or "," in selector:
|
||
continue
|
||
scoped.append(f".ct-word-doc--v266 {selector}{{{props}}}")
|
||
return "\n".join(scoped)
|
||
|
||
|
||
def convert_html(raw: str) -> str:
|
||
css_match = re.search(r"<style[^>]*>([\s\S]*?)</style>", raw)
|
||
body_match = re.search(r"<body>([\s\S]*?)</body>", raw)
|
||
if not css_match or not body_match:
|
||
raise SystemExit("Invalid source HTML")
|
||
|
||
rules = parse_css_rules(css_match.group(1))
|
||
red_classes = build_red_classes(rules)
|
||
scoped = scope_css(css_match.group(1))
|
||
|
||
soup = BeautifulSoup(body_match.group(1), "lxml")
|
||
strip_apple_noise(soup)
|
||
|
||
for tag in soup.find_all(True):
|
||
merge_style(tag, rules)
|
||
|
||
wrap_risk_redlines(soup, red_classes)
|
||
apply_semantic_classes(soup, DEFAULT_SEMANTIC)
|
||
map_tables(soup)
|
||
|
||
body_html = "".join(str(c) for c in (soup.body or soup).contents)
|
||
body_html = apply_template_vars(body_html)
|
||
body_html = re.sub(r"<p class=\"p\d+\"><br\s*/?></p>\s*", "", body_html, count=3)
|
||
|
||
return (
|
||
'<div class="ct-word-doc ct-word-doc--v266">'
|
||
f"<style>{scoped}</style>"
|
||
f"{body_html}"
|
||
"</div>"
|
||
)
|
||
|
||
|
||
def export_docx(docx: Path, out: Path, export_name: str) -> None:
|
||
with tempfile.NamedTemporaryFile(suffix=".html", delete=False) as tmp:
|
||
tmp_path = Path(tmp.name)
|
||
subprocess.run(
|
||
["textutil", "-convert", "html", "-output", str(tmp_path), str(docx)],
|
||
check=True,
|
||
)
|
||
raw = tmp_path.read_text(encoding="utf-8")
|
||
tmp_path.unlink(missing_ok=True)
|
||
html = convert_html(raw)
|
||
escaped = json.dumps(html, ensure_ascii=False)
|
||
out.write_text(
|
||
f"// AUTO-GENERATED from {docx.name} — do not edit by hand\n"
|
||
f"export var {export_name} = {escaped};\n",
|
||
encoding="utf-8",
|
||
)
|
||
print(f"Wrote {out} ({out.stat().st_size} bytes), redlines={html.count('data-risk-redline')}")
|
||
|
||
|
||
def main() -> None:
|
||
parser = argparse.ArgumentParser()
|
||
parser.add_argument("docx", type=Path)
|
||
parser.add_argument("out", type=Path)
|
||
parser.add_argument("export_name")
|
||
args = parser.parse_args()
|
||
export_docx(args.docx, args.out, args.export_name)
|
||
|
||
|
||
if __name__ == "__main__":
|
||
main()
|