Nature Paper To Patent

{
  "skill_name": "nature-paper-to-patent",
  "evals": [
    {
      "id": 1,
      "prompt": "分析一篇包含模型结构、损失函数和检测流程的PDF论文，生成完整的中国发明专利初稿。分别输出权利要求书、说明书、说明书摘要和摘要附图。所有核心公式必须是Word原生可编辑公式，每项权利要求特征必须能回溯到论文页码或公式。",
      "expected_output": "A complete Chinese patent package with stable source IDs, evidence ledger, claim-feature map, editable equations, a claim-aligned main flowchart, methodology figures, separate DOCX files, and passing validation reports.",
      "files": []
    },
    {
      "id": 2,
      "prompt": "论文是扫描版PDF，部分公式OCR不清楚。请先整理可确认的技术方案并生成权利要求草案，不确定的公式符号不要猜。",
      "expected_output": "An OCR-aware claim draft that marks uncertain source blocks, excludes unsupported limitations from formal claims, lists specific inventor questions, and does not fabricate equation symbols.",
      "files": []
    },
    {
      "id": 3,
      "prompt": "对照论文和一份已有专利，逐项判断专利权利要求在论文中是否有支持，并标注论文独有、专利独有、专利更宽或更窄的内容。",
      "expected_output": "Separate source maps plus a bidirectional feature table using the declared relationship labels, exact locators for both documents, and no assumption that patent-only text is paper-supported.",
      "files": []
    }
  ]
}

name: nature-paper-to-patent
version: 1.0.0
description: >
  Agent-neutral routing manifest for converting research disclosures into
  evidence-grounded Chinese invention patent drafts.

always_load:
  - static/core/principles.md
  - static/core/workflow.md
  - static/core/output-contract.md

axes:
  source_format:
    detect: >
      Use pdf-text for a selectable-text PDF, scanned-pdf for an image-only or
      OCR-required PDF, pasted-text for user-provided prose, and mixed-project
      when the workspace also contains source code, supplementary files,
      inventor notes, figures, or an existing patent.
    values:
      pdf-text: static/fragments/source/pdf-text.md
      scanned-pdf: static/fragments/source/scanned-pdf.md
      pasted-text: static/fragments/source/pasted-text.md
      mixed-project: static/fragments/source/mixed-project.md
    default: pdf-text
    multi: true

  task_mode:
    detect: >
      Use full-draft for a complete application package, claim-set for claims
      only, disclosure-analysis for patentability-oriented technical
      extraction, and paper-patent-audit for comparison with an existing
      patent.
    values:
      full-draft: static/fragments/task/full-draft.md
      claim-set: static/fragments/task/claim-set.md
      disclosure-analysis: static/fragments/task/disclosure-analysis.md
      paper-patent-audit: static/fragments/task/paper-patent-audit.md
    default: full-draft
    multi: false

  invention_type:
    detect: >
      Determine the dominant technical subject. Use algorithm-software for
      data processing, AI, signal processing, control, or computer-implemented
      methods; apparatus-system for physical structures or cooperating
      devices; process-material for manufacturing, chemistry, or material
      preparation; and mixed when no single category is sufficient.
    values:
      algorithm-software: static/fragments/invention/algorithm-software.md
      apparatus-system: static/fragments/invention/apparatus-system.md
      process-material: static/fragments/invention/process-material.md
      mixed: static/fragments/invention/mixed.md
    default: algorithm-software
    multi: false

references:
  on_demand:
    - condition: drafting or auditing Chinese claims and specification
      path: references/cn-patent-drafting-guide.md
    - condition: creating figures or selecting a paper methodology figure
      path: references/patent-figure-guide.md
    - condition: populating or validating the structured draft
      path: references/draft-schema.md
    - condition: learning transformations from paired paper-patent examples
      path: references/corpus-derived-patterns.md
    - condition: comparing a supplied paper with an existing patent
      path: references/corpus-pair-audit.md

latex2mathml>=3.77.0
Pillow>=10.0.0
pypdf>=4.0.0
python-docx>=1.1.0

#!/usr/bin/env python3
"""Run deterministic structural checks on Chinese patent claims."""

import argparse
import json
import re
from dataclasses import dataclass
from pathlib import Path


CLAIM_START = re.compile(r"(?m)^\s*(\d+)\s*[.、．]\s*")
REFERENCE = re.compile(
    r"权利要求\s*(\d+)(?:\s*[-—~～至]\s*(\d+))?"
    r"|权利要求\s*(\d+)\s*(?:或|、)\s*(\d+)"
)
TERM_INTRO = re.compile(r"(?:所述|该)([\u4e00-\u9fffA-Za-z][\u4e00-\u9fffA-Za-z0-9_-]{1,20})")
PLACEHOLDER = re.compile(r"\[(?:TO CONFIRM|待确认)[^\]]*\]", re.IGNORECASE)


@dataclass
class Finding:
    level: str
    claim: int | None
    code: str
    message: str


def split_claims(text: str) -> list[tuple[int, str]]:
    matches = list(CLAIM_START.finditer(text))
    claims = []
    for index, match in enumerate(matches):
        end = matches[index + 1].start() if index + 1 < len(matches) else len(text)
        claims.append((int(match.group(1)), text[match.end() : end].strip()))
    return claims


def references(body: str) -> list[int]:
    result = []
    for match in REFERENCE.finditer(body):
        if match.group(1):
            start = int(match.group(1))
            finish = int(match.group(2) or start)
            result.extend(range(start, finish + 1))
        else:
            result.extend((int(match.group(3)), int(match.group(4))))
    return sorted(set(result))


def normalize(text: str) -> str:
    return re.sub(r"\s+", "", text)


def audit(text: str) -> list[Finding]:
    claims = split_claims(text)
    findings = []
    if not claims:
        return [Finding("ERROR", None, "NO_CLAIMS", "未识别到以“1.”形式起始的权利要求。")]

    numbers = [number for number, _ in claims]
    expected = list(range(1, len(claims) + 1))
    if numbers != expected:
        findings.append(
            Finding("ERROR", None, "NUMBER_SEQUENCE", f"编号应连续为{expected}，实际为{numbers}。")
        )

    previous_text = ""
    claim_map = {}
    for number, body in claims:
        compact = normalize(body)
        claim_map[number] = compact
        refs = references(body)

        if not body:
            findings.append(Finding("ERROR", number, "EMPTY", "权利要求正文为空。"))
            continue
        if PLACEHOLDER.search(body):
            findings.append(
                Finding("ERROR", number, "PLACEHOLDER", "正式权利要求中仍含待确认标记。")
            )
        if number == 1 and refs:
            findings.append(
                Finding("ERROR", number, "INDEPENDENT_REFERENCE", "权利要求1不应引用其他权利要求。")
            )
        if number > 1 and not refs:
            findings.append(
                Finding("WARNING", number, "NO_REFERENCE", "未检测到从属引用；确认其是否为独立权利要求。")
            )
        for ref in refs:
            if ref >= number:
                findings.append(
                    Finding("ERROR", number, "FORWARD_REFERENCE", f"引用了非在先权利要求{ref}。")
                )
            if ref not in claim_map:
                findings.append(
                    Finding("ERROR", number, "MISSING_REFERENCE", f"引用的权利要求{ref}不存在。")
                )

        if "其特征在于" not in compact:
            findings.append(
                Finding("WARNING", number, "TRANSITION", "未检测到“其特征在于”过渡语。")
            )
        if len(compact) < 25:
            findings.append(
                Finding("WARNING", number, "TOO_SHORT", "权利要求较短，确认是否完整限定技术方案。")
            )
        if re.search(r"(效果更好|性能优异|显著提高|大大提高|最佳|最优)", compact):
            findings.append(
                Finding("WARNING", number, "RESULT_LANGUAGE", "含结果或宣传性措辞，确认是否改为技术限定。")
            )

        searchable_basis = previous_text + "".join(
            claim_map.get(ref, "") for ref in refs
        )
        for term in sorted(set(TERM_INTRO.findall(body))):
            if term in {"方法", "装置", "设备", "系统", "步骤", "程序"}:
                continue
            if term not in searchable_basis and compact.find(term) <= 4:
                findings.append(
                    Finding(
                        "WARNING",
                        number,
                        "ANTECEDENT_BASIS",
                        f"术语“{term}”可能缺少清晰的前置基础。",
                    )
                )
        previous_text += compact

    return findings


def main() -> int:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("claims", type=Path, help="UTF-8 claims text file")
    parser.add_argument("--json", action="store_true", help="Output findings as JSON")
    args = parser.parse_args()

    text = args.claims.read_text(encoding="utf-8")
    findings = audit(text)
    if args.json:
        print(json.dumps([finding.__dict__ for finding in findings], ensure_ascii=False, indent=2))
    elif not findings:
        print("PASS: 未发现结构性问题。")
    else:
        for finding in findings:
            location = f"权利要求{finding.claim}" if finding.claim else "整体"
            print(f"{finding.level}\t{location}\t{finding.code}\t{finding.message}")
        errors = sum(finding.level == "ERROR" for finding in findings)
        warnings = sum(finding.level == "WARNING" for finding in findings)
        print(f"\n汇总: {errors} 个错误, {warnings} 个警告")

    return 1 if any(finding.level == "ERROR" for finding in findings) else 0


if __name__ == "__main__":
    raise SystemExit(main())

#!/usr/bin/env python3
"""Build the standard split Chinese patent application package."""

import argparse
import importlib.util
import json
import shutil
import subprocess
import sys
from pathlib import Path


def run(command: list[str]) -> None:
    subprocess.run(command, check=True)


def validate(data: dict) -> None:
    required = ("title", "claims", "specification", "abstract", "figures")
    missing = [key for key in required if not data.get(key)]
    if missing:
        raise ValueError(f"Missing required complete-package content: {', '.join(missing)}")
    spec = data["specification"]
    if not spec.get("figure_descriptions"):
        raise ValueError("Specification must contain figure descriptions")
    if "equations" not in spec:
        raise ValueError(
            "Specification must contain an equations array; use an empty array only when "
            "the source contains no core technical formulas"
        )
    source_analysis = data.get("source_analysis", {})
    if source_analysis.get("contains_core_formulas") and not spec.get("equations"):
        raise ValueError(
            "The source is marked as containing core formulas, but specification.equations is empty"
        )
    for equation in spec.get("equations", []):
        if not equation.get("latex"):
            raise ValueError(
                f"Equation {equation.get('number')} must include latex source for native Office Math"
            )
    equation_numbers = [item.get("number") for item in spec.get("equations", [])]
    if equation_numbers and equation_numbers != list(range(1, len(equation_numbers) + 1)):
        raise ValueError(
            f"Equation numbers must be consecutive integers starting at 1: {equation_numbers}"
        )
    abstract_figure_number = data.get("abstract_figure_number")
    if not isinstance(abstract_figure_number, int):
        raise ValueError("abstract_figure_number must be an integer")
    figure = next(
        (
            item
            for item in data["figures"]
            if item.get("number") == abstract_figure_number
        ),
        None,
    )
    if figure is None:
        raise ValueError(
            f"abstract_figure_number {abstract_figure_number} does not reference an existing figure"
        )
    if not figure.get("complete_claim_flow"):
        raise ValueError("The abstract figure must be a complete principal claim flow")
    if source_analysis.get("contains_methodology_figures"):
        methodology = [item for item in data["figures"] if item.get("type") == "methodology"]
        if not methodology:
            raise ValueError(
                "The source is marked as containing methodology figures, but no methodology "
                "figure is included"
            )


def main() -> int:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("draft", type=Path, help="UTF-8 patent draft JSON")
    parser.add_argument("--output-dir", type=Path, required=True)
    parser.add_argument("--prefix", default="patent")
    args = parser.parse_args()

    data = json.loads(args.draft.read_text(encoding="utf-8"))
    root = Path(__file__).resolve().parent
    validator_script = root / "validate_patent_draft.py"
    validator_spec = importlib.util.spec_from_file_location(
        "patent_draft_validator", validator_script
    )
    validator = importlib.util.module_from_spec(validator_spec)
    sys.modules[validator_spec.name] = validator
    validator_spec.loader.exec_module(validator)
    validation_findings = validator.validate(data)
    args.output_dir.mkdir(parents=True, exist_ok=True)
    validation_report = args.output_dir / f"{args.prefix}-草稿验证报告.txt"
    validation_report.write_text(
        validator.format_report(validation_findings), encoding="utf-8"
    )
    if any(item.level == "ERROR" for item in validation_findings):
        print(validation_report)
        raise SystemExit(1)

    validate(data)
    docx_script = root / "render_patent_docx.py"
    figure_script = root / "render_flowchart_svg.py"

    figure_dir = args.output_dir / f"{args.prefix}-figures"
    run(
        [
            sys.executable,
            str(figure_script),
            str(args.draft),
            "--output-dir",
            str(figure_dir),
            "--png",
        ]
    )

    outputs = {
        "claims": args.output_dir / f"{args.prefix}-权利要求书.docx",
        "specification": args.output_dir / f"{args.prefix}-说明书.docx",
        "abstract": args.output_dir / f"{args.prefix}-说明书摘要.docx",
        "abstract-figure": args.output_dir / f"{args.prefix}-摘要附图.docx",
        "all": args.output_dir / f"{args.prefix}-完整审阅稿.docx",
    }
    for part, output in outputs.items():
        command = [
            sys.executable,
            str(docx_script),
            str(args.draft),
            "--output",
            str(output),
            "--part",
            part,
        ]
        if part in {"specification", "abstract", "abstract-figure", "all"}:
            command.extend(["--figure-dir", str(figure_dir)])
        run(command)

    claims_text = args.output_dir / f"{args.prefix}-权利要求书.txt"
    claims_text.write_text(
        "\n".join(f"{claim['number']}. {claim['text']}" for claim in data["claims"]) + "\n",
        encoding="utf-8",
    )
    audit = args.output_dir / f"{args.prefix}-权利要求检查.txt"
    audit_script = root / "audit_claims.py"
    spec = importlib.util.spec_from_file_location("patent_claim_audit", audit_script)
    audit_module = importlib.util.module_from_spec(spec)
    sys.modules[spec.name] = audit_module
    spec.loader.exec_module(audit_module)
    findings = audit_module.audit(claims_text.read_text(encoding="utf-8"))
    if findings:
        lines = []
        for finding in findings:
            location = f"权利要求{finding.claim}" if finding.claim else "整体"
            lines.append(
                f"{finding.level}\t{location}\t{finding.code}\t{finding.message}"
            )
    else:
        lines = ["PASS: 未发现权利要求结构性问题。"]
    audit.write_text("\n".join(lines) + "\n", encoding="utf-8")
    if any(finding.level == "ERROR" for finding in findings):
        raise SystemExit(1)

    json_copy = args.output_dir / f"{args.prefix}-结构化草稿.json"
    if args.draft.resolve() != json_copy.resolve():
        shutil.copy2(args.draft, json_copy)

    for output in (*outputs.values(), json_copy, audit, validation_report):
        print(output)
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

#!/usr/bin/env python3
"""Extract searchable text from one PDF or a directory of PDFs."""

import argparse
from pathlib import Path

from pypdf import PdfReader


def extract(source: Path, destination: Path) -> tuple[int, int]:
    reader = PdfReader(source)
    pages = []
    for number, page in enumerate(reader.pages, start=1):
        text = page.extract_text() or ""
        pages.append(f"\n\n===== PAGE {number} =====\n\n{text}")

    content = "".join(pages)
    destination.parent.mkdir(parents=True, exist_ok=True)
    destination.write_text(content, encoding="utf-8")
    return len(reader.pages), len(content.strip())


def collect_pdfs(source: Path) -> list[Path]:
    if source.is_file():
        if source.suffix.lower() != ".pdf":
            raise ValueError(f"Input is not a PDF: {source}")
        return [source]
    if source.is_dir():
        return sorted(path for path in source.rglob("*.pdf") if path.is_file())
    raise FileNotFoundError(f"Input does not exist: {source}")


def output_path(pdf: Path, source: Path, output: Path) -> Path:
    if source.is_file():
        if output.suffix.lower() == ".txt":
            return output
        return output / f"{pdf.stem}.txt"
    relative = pdf.relative_to(source).with_suffix(".txt")
    return output / relative


def main() -> int:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("source", type=Path, help="PDF file or directory")
    parser.add_argument(
        "--output",
        type=Path,
        required=True,
        help="Output text file or directory",
    )
    args = parser.parse_args()

    try:
        pdfs = collect_pdfs(args.source)
    except (FileNotFoundError, ValueError) as error:
        parser.error(str(error))

    if not pdfs:
        parser.error(f"No PDF files found under: {args.source}")

    low_text = []
    for pdf in pdfs:
        destination = output_path(pdf, args.source, args.output)
        pages, characters = extract(pdf, destination)
        print(f"{pdf}\t{pages} pages\t{characters} characters\t{destination}")
        if characters < max(200, pages * 50):
            low_text.append(pdf)

    if low_text:
        print("\nOCR may be required for:")
        for pdf in low_text:
            print(f"- {pdf}")
        return 2
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

#!/usr/bin/env python3
"""Create an agent-neutral paper-to-patent project workspace."""

import argparse
import json
import shutil
from pathlib import Path


DIRECTORIES = (
    "paper",
    "supplementary/source-code",
    "source-figures",
    "existing-patent",
    "work",
    "outputs",
)
SKILL_FILES = ("SKILL.md", "manifest.yaml", "requirements.txt")
SKILL_DIRECTORIES = ("static", "references", "scripts")


def main() -> int:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("project_dir", type=Path)
    parser.add_argument("--paper", type=Path, help="Optional paper to copy into paper/")
    parser.add_argument("--force", action="store_true", help="Allow an existing project directory")
    parser.add_argument(
        "--no-embed-skill",
        action="store_true",
        help="Create only case directories without copying the skill bundle",
    )
    args = parser.parse_args()

    project = args.project_dir.resolve()
    if project.exists() and any(project.iterdir()) and not args.force:
        parser.error("project directory is not empty; use --force to add missing structure")
    project.mkdir(parents=True, exist_ok=True)
    for directory in DIRECTORIES:
        (project / directory).mkdir(parents=True, exist_ok=True)

    if not args.no_embed_skill:
        skill_root = Path(__file__).resolve().parents[1]
        if project != skill_root:
            for filename in SKILL_FILES:
                shutil.copy2(skill_root / filename, project / filename)
            for directory in SKILL_DIRECTORIES:
                shutil.copytree(
                    skill_root / directory,
                    project / directory,
                    dirs_exist_ok=True,
                    ignore=shutil.ignore_patterns("__pycache__", "*.pyc"),
                )

    if args.paper:
        paper = args.paper.resolve()
        if not paper.is_file():
            parser.error(f"paper does not exist: {paper}")
        shutil.copy2(paper, project / "paper" / paper.name)

    intake = {
        "target_jurisdiction": "中国发明专利",
        "requested_deliverable": "full-draft",
        "publication_status": "[TO CONFIRM: 论文是否已经公开]",
        "publication_dates": [],
        "inventorship": "[TO CONFIRM: 按实际技术贡献确认发明人]",
        "ownership": "[TO CONFIRM: 确认申请人和权属]",
        "source_files": [],
    }
    intake_path = project / "work" / "00-intake.json"
    if not intake_path.exists():
        intake_path.write_text(
            json.dumps(intake, ensure_ascii=False, indent=2) + "\n",
            encoding="utf-8",
        )

    notes = project / "supplementary" / "inventor-notes.md"
    if not notes.exists():
        notes.write_text(
            "# 发明人补充说明\n\n"
            "- 实际技术贡献：\n"
            "- 与论文不同的工程实现：\n"
            "- 可替代方案和参数范围：\n"
            "- 首次公开时间与方式：\n"
            "- 希望重点保护的内容：\n",
            encoding="utf-8",
        )

    print(project)
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

#!/usr/bin/env python3
"""Convert a LaTeX equation into editable Word Office Math (OMML)."""

from copy import deepcopy
from xml.etree import ElementTree

from docx.oxml import OxmlElement
from docx.oxml.ns import qn


MATHML_NS = "{http://www.w3.org/1998/Math/MathML}"


def _element(name: str):
    return OxmlElement(f"m:{name}")


def _text_run(text: str):
    run = _element("r")
    properties = _element("rPr")
    style = _element("sty")
    style.set(qn("m:val"), "p")
    properties.append(style)
    run.append(properties)
    value = _element("t")
    value.text = text
    run.append(value)
    return run


def _append_children(target, source) -> None:
    if source.text and source.text.strip():
        target.append(_text_run(source.text.strip()))
    for child in source:
        _append_mathml(target, child)
        if child.tail and child.tail.strip():
            target.append(_text_run(child.tail.strip()))


def _script(target, node, kind: str) -> None:
    result = _element(kind)
    expression = _element("e")
    sub = _element("sub")
    sup = _element("sup")
    children = list(node)
    if children:
        _append_mathml(expression, children[0])
    if len(children) > 1:
        _append_mathml(sub, children[1])
    if len(children) > 2:
        _append_mathml(sup, children[2])
    result.append(expression)
    if kind in {"sSub", "sSubSup"}:
        result.append(sub)
    if kind in {"sSup", "sSubSup"}:
        result.append(sup if kind == "sSubSup" else sub)
    target.append(result)


def _append_mathml(target, node) -> None:
    tag = node.tag.removeprefix(MATHML_NS)
    children = list(node)

    if tag in {"math", "mrow", "mstyle", "semantics", "annotation"}:
        _append_children(target, node)
    elif tag in {"mi", "mn", "mo", "mtext"}:
        target.append(_text_run("".join(node.itertext())))
    elif tag == "mfrac":
        fraction = _element("f")
        numerator = _element("num")
        denominator = _element("den")
        if children:
            _append_mathml(numerator, children[0])
        if len(children) > 1:
            _append_mathml(denominator, children[1])
        fraction.extend((numerator, denominator))
        target.append(fraction)
    elif tag == "msub":
        _script(target, node, "sSub")
    elif tag == "msup":
        _script(target, node, "sSup")
    elif tag in {"msubsup", "munderover"}:
        _script(target, node, "sSubSup")
    elif tag == "munder":
        _script(target, node, "sSub")
    elif tag == "mover":
        _script(target, node, "sSup")
    elif tag == "msqrt":
        radical = _element("rad")
        properties = _element("radPr")
        hide_degree = _element("degHide")
        hide_degree.set(qn("m:val"), "1")
        properties.append(hide_degree)
        degree = _element("deg")
        expression = _element("e")
        _append_children(expression, node)
        radical.extend((properties, degree, expression))
        target.append(radical)
    elif tag == "mroot":
        radical = _element("rad")
        degree = _element("deg")
        expression = _element("e")
        if children:
            _append_mathml(expression, children[0])
        if len(children) > 1:
            _append_mathml(degree, children[1])
        radical.extend((degree, expression))
        target.append(radical)
    elif tag == "mfenced":
        delimiter = _element("d")
        properties = _element("dPr")
        begin = _element("begChr")
        begin.set(qn("m:val"), node.attrib.get("open", "("))
        end = _element("endChr")
        end.set(qn("m:val"), node.attrib.get("close", ")"))
        properties.extend((begin, end))
        expression = _element("e")
        _append_children(expression, node)
        delimiter.extend((properties, expression))
        target.append(delimiter)
    elif tag == "mtable":
        matrix = _element("m")
        for row_node in children:
            row = _element("mr")
            for cell_node in list(row_node):
                cell = _element("e")
                _append_children(cell, cell_node)
                row.append(cell)
            matrix.append(row)
        target.append(matrix)
    elif tag in {"mtr", "mtd"}:
        _append_children(target, node)
    elif tag == "mspace":
        target.append(_text_run(" "))
    else:
        _append_children(target, node)


def latex_to_omml(latex: str):
    try:
        from latex2mathml.converter import convert
    except ImportError as error:
        raise RuntimeError(
            "Native equations require latex2mathml: py -3 -m pip install latex2mathml"
        ) from error

    mathml = ElementTree.fromstring(convert(latex))
    paragraph = _element("oMathPara")
    math = _element("oMath")
    _append_mathml(math, mathml)
    paragraph.append(math)
    return paragraph


def clone_omml(element):
    return deepcopy(element)

#!/usr/bin/env python3
"""Render patent-style black-and-white flowchart SVGs from draft JSON."""

import argparse
import html
import json
import re
import textwrap
from pathlib import Path


STEP_PATTERN = re.compile(r"\bS\s*(\d+)\b", re.IGNORECASE)
ASCII_ID = re.compile(r"^[A-Za-z][A-Za-z0-9_-]*$")
VAGUE_FINAL_RESULT = re.compile(r"(技术结果|处理结果|最终结果)")


def normalize_step(value: str) -> str:
    match = STEP_PATTERN.fullmatch(str(value).strip())
    return f"S{match.group(1)}" if match else str(value).strip()


def claim_step_map(claims: list[dict]) -> dict[int, set[str]]:
    result = {}
    for claim in claims:
        number = claim.get("number")
        result[number] = {f"S{value}" for value in STEP_PATTERN.findall(claim.get("text", ""))}
    return result


def validate_figure(
    figure: dict,
    steps_by_claim: dict[int, set[str]],
    descriptions: list[str],
) -> list[str]:
    errors = []
    figure_type = figure.get("type")
    if figure_type not in {"flowchart", "methodology"}:
        errors.append("type must be 'flowchart' or 'methodology'")
    if figure.get("orientation", "vertical") not in {"vertical", "horizontal"}:
        errors.append("orientation must be 'vertical' or 'horizontal'")
    claim_number = figure.get("claim_number", 1)
    available_steps = set()
    if figure_type == "flowchart":
        if claim_number not in steps_by_claim:
            errors.append(f"claim_number {claim_number!r} does not exist")
        available_steps = steps_by_claim.get(claim_number, set())

    nodes = figure.get("nodes", [])
    if not nodes:
        errors.append("at least one node is required")
    ids = [str(node.get("id", "")) for node in nodes]
    if len(ids) != len(set(ids)):
        errors.append("node ids must be unique")
    for node in nodes:
        node_id = str(node.get("id", ""))
        if not ASCII_ID.fullmatch(node_id):
            errors.append(f"invalid node id: {node_id!r}")
        if not str(node.get("label", "")).strip():
            errors.append(f"node {node_id!r} has an empty label")
        step = normalize_step(node.get("claim_step", ""))
        if figure_type == "flowchart" and step and step not in available_steps:
            errors.append(
                f"node {node_id!r} references step {step!r}, not found in claim {claim_number}"
            )

    node_steps = {
        normalize_step(node.get("claim_step", ""))
        for node in nodes
        if str(node.get("claim_step", "")).strip()
    }
    if figure_type == "flowchart" and figure.get("complete_claim_flow") and node_steps != available_steps:
        missing = sorted(available_steps - node_steps)
        extra = sorted(node_steps - available_steps)
        if missing:
            errors.append(f"complete claim flow is missing steps: {missing}")
        if extra:
            errors.append(f"complete claim flow contains extra steps: {extra}")

    figure_token = f"图{figure.get('number')}"
    if not any(figure_token in str(description) for description in descriptions):
        errors.append(f"figure description does not reference {figure_token}")

    id_set = set(ids)
    incoming = {node_id: 0 for node_id in ids}
    outgoing = {node_id: 0 for node_id in ids}
    for edge in figure.get("edges", []):
        source = str(edge.get("from", ""))
        target = str(edge.get("to", ""))
        if source not in id_set:
            errors.append(f"edge source {source!r} does not exist")
        if target not in id_set:
            errors.append(f"edge target {target!r} does not exist")
        if source == target and source:
            errors.append(f"self-loop is not allowed for node {source!r}")
        if source in outgoing:
            outgoing[source] += 1
        if target in incoming:
            incoming[target] += 1

    if len(nodes) > 1 and not figure.get("edges"):
        errors.append("multiple nodes require edges")
    if len(nodes) > 1:
        if not any(value == 0 for value in incoming.values()):
            errors.append("flowchart has no start node")
        if not any(value == 0 for value in outgoing.values()):
            errors.append("flowchart has no end node")
        starts = [node_id for node_id, count in incoming.items() if count == 0]
        adjacency = {node_id: set() for node_id in ids}
        for edge in figure.get("edges", []):
            source = str(edge.get("from", ""))
            target = str(edge.get("to", ""))
            if source in adjacency and target in id_set:
                adjacency[source].add(target)
        reachable = set(starts)
        pending = list(starts)
        while pending:
            current = pending.pop()
            for target in adjacency[current]:
                if target not in reachable:
                    reachable.add(target)
                    pending.append(target)
        disconnected = sorted(id_set - reachable)
        if disconnected:
            errors.append(f"unreachable nodes from any start node: {disconnected}")
    for node in nodes:
        node_id = str(node.get("id", ""))
        if outgoing.get(node_id) == 0 and VAGUE_FINAL_RESULT.search(str(node.get("label", ""))):
            errors.append(
                f"end node {node_id!r} uses a vague result name; state the specific detection, "
                "estimation, classification, positioning, or control result"
            )
    return errors


def wrap_label(label: str, width: int = 18) -> list[str]:
    chunks = []
    for paragraph in str(label).splitlines() or [""]:
        chunks.extend(textwrap.wrap(paragraph, width=width) or [""])
    return chunks


def layout(figure: dict) -> tuple[dict[str, tuple[int, int, int, int]], int, int]:
    orientation = figure.get("orientation", "vertical")
    nodes = figure["nodes"]
    box_width = 360
    gap = 90
    margin = 70
    positions = {}
    max_height = 0
    heights = []
    for node in nodes:
        line_count = len(wrap_label(node["label"]))
        height = max(72, 34 + line_count * 24)
        heights.append(height)
        max_height = max(max_height, height)

    if orientation == "vertical":
        y = margin + 45
        for node, height in zip(nodes, heights):
            positions[node["id"]] = (margin, y, box_width, height)
            y += height + gap
        width = box_width + margin * 2
        height = y - gap + margin
    else:
        x = margin
        for node, height in zip(nodes, heights):
            positions[node["id"]] = (x, margin + 45, box_width, height)
            x += box_width + gap
        width = x - gap + margin
        height = max_height + margin * 2 + 45
    return positions, width, height


def anchor(box: tuple[int, int, int, int], side: str) -> tuple[float, float]:
    x, y, width, height = box
    points = {
        "top": (x + width / 2, y),
        "bottom": (x + width / 2, y + height),
        "left": (x, y + height / 2),
        "right": (x + width, y + height / 2),
    }
    return points[side]


def render(figure: dict) -> str:
    positions, width, height = layout(figure)
    orientation = figure.get("orientation", "vertical")
    title = f"图{figure['number']} {figure.get('title', '方法流程图')}"
    parts = [
        '<?xml version="1.0" encoding="UTF-8"?>',
        f'<svg xmlns="http://www.w3.org/2000/svg" width="{width}" height="{height}" '
        f'viewBox="0 0 {width} {height}" role="img" aria-label="{html.escape(title)}">',
        "<defs>",
        '<marker id="arrow" viewBox="0 0 10 10" refX="9" refY="5" markerWidth="8" '
        'markerHeight="8" orient="auto-start-reverse">',
        '<path d="M 0 0 L 10 5 L 0 10 z" fill="#000"/>',
        "</marker>",
        "</defs>",
        '<rect width="100%" height="100%" fill="#fff"/>',
        f'<text x="{width / 2}" y="28" text-anchor="middle" '
        'font-family="SimSun, Songti SC, serif" font-size="20">'
        f"{html.escape(title)}</text>",
    ]

    for edge in figure.get("edges", []):
        source_box = positions[edge["from"]]
        target_box = positions[edge["to"]]
        source_side, target_side = (
            ("bottom", "top") if orientation == "vertical" else ("right", "left")
        )
        x1, y1 = anchor(source_box, source_side)
        x2, y2 = anchor(target_box, target_side)
        parts.append(
            f'<line x1="{x1}" y1="{y1}" x2="{x2}" y2="{y2}" '
            'stroke="#000" stroke-width="2" marker-end="url(#arrow)"/>'
        )
        label = str(edge.get("label", "")).strip()
        if label:
            parts.append(
                f'<text x="{(x1 + x2) / 2 + 8}" y="{(y1 + y2) / 2 - 8}" '
                'font-family="SimSun, Songti SC, serif" font-size="16">'
                f"{html.escape(label)}</text>"
            )

    for node in figure["nodes"]:
        x, y, box_width, box_height = positions[node["id"]]
        parts.append(
            f'<rect x="{x}" y="{y}" width="{box_width}" height="{box_height}" '
            'rx="0" fill="#fff" stroke="#000" stroke-width="2"/>'
        )
        lines = wrap_label(node["label"])
        start_y = y + box_height / 2 - (len(lines) - 1) * 12
        for index, line in enumerate(lines):
            parts.append(
                f'<text x="{x + box_width / 2}" y="{start_y + index * 24}" '
                'text-anchor="middle" dominant-baseline="middle" '
                'font-family="SimSun, Songti SC, serif" font-size="18">'
                f"{html.escape(line)}</text>"
            )

    parts.append("</svg>")
    return "\n".join(parts)


def load_font(size: int):
    from PIL import ImageFont

    candidates = (
        Path(r"C:\Windows\Fonts\simsun.ttc"),
        Path(r"C:\Windows\Fonts\msyh.ttc"),
        Path(r"C:\Windows\Fonts\simhei.ttf"),
    )
    for candidate in candidates:
        if candidate.exists():
            return ImageFont.truetype(str(candidate), size=size)
    return ImageFont.load_default()


def render_png(figure: dict, output: Path) -> None:
    from PIL import Image, ImageDraw

    positions, width, height = layout(figure)
    scale = 2
    image = Image.new("RGB", (width * scale, height * scale), "white")
    draw = ImageDraw.Draw(image)
    title_font = load_font(20 * scale)
    body_font = load_font(18 * scale)
    edge_font = load_font(16 * scale)

    def point(value: float) -> int:
        return int(round(value * scale))

    title = f"图{figure['number']} {figure.get('title', '方法流程图')}"
    title_box = draw.textbbox((0, 0), title, font=title_font)
    title_x = (width * scale - (title_box[2] - title_box[0])) / 2
    draw.text((title_x, point(8)), title, fill="black", font=title_font)

    orientation = figure.get("orientation", "vertical")
    for edge in figure.get("edges", []):
        source_box = positions[edge["from"]]
        target_box = positions[edge["to"]]
        source_side, target_side = (
            ("bottom", "top") if orientation == "vertical" else ("right", "left")
        )
        x1, y1 = anchor(source_box, source_side)
        x2, y2 = anchor(target_box, target_side)
        draw.line((point(x1), point(y1), point(x2), point(y2)), fill="black", width=4)
        if orientation == "vertical":
            arrow = [
                (point(x2), point(y2)),
                (point(x2 - 7), point(y2 - 12)),
                (point(x2 + 7), point(y2 - 12)),
            ]
        else:
            arrow = [
                (point(x2), point(y2)),
                (point(x2 - 12), point(y2 - 7)),
                (point(x2 - 12), point(y2 + 7)),
            ]
        draw.polygon(arrow, fill="black")
        label = str(edge.get("label", "")).strip()
        if label:
            draw.text(
                (point((x1 + x2) / 2 + 8), point((y1 + y2) / 2 - 20)),
                label,
                fill="black",
                font=edge_font,
            )

    for node in figure["nodes"]:
        x, y, box_width, box_height = positions[node["id"]]
        draw.rectangle(
            (point(x), point(y), point(x + box_width), point(y + box_height)),
            fill="white",
            outline="black",
            width=4,
        )
        lines = wrap_label(node["label"])
        line_height = 24 * scale
        total_height = line_height * len(lines)
        text_y = point(y + box_height / 2) - total_height / 2
        for line in lines:
            text_box = draw.textbbox((0, 0), line, font=body_font)
            text_width = text_box[2] - text_box[0]
            text_x = point(x + box_width / 2) - text_width / 2
            draw.text((text_x, text_y), line, fill="black", font=body_font)
            text_y += line_height

    output.parent.mkdir(parents=True, exist_ok=True)
    image.save(output, format="PNG", dpi=(300, 300))


def main() -> int:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("draft", type=Path, help="UTF-8 patent draft JSON")
    parser.add_argument("--output-dir", type=Path, required=True, help="SVG output directory")
    parser.add_argument("--png", action="store_true", help="Also render PNG files")
    args = parser.parse_args()

    data = json.loads(args.draft.read_text(encoding="utf-8"))
    figures = data.get("figures", [])
    if not figures:
        parser.error("draft contains no figures")
    numbers = [figure.get("number") for figure in figures]
    if numbers != list(range(1, len(figures) + 1)):
        parser.error(f"figure numbers must be consecutive starting at 1: {numbers}")

    steps = claim_step_map(data.get("claims", []))
    descriptions = data.get("specification", {}).get("figure_descriptions", [])
    all_errors = []
    for figure in figures:
        errors = validate_figure(figure, steps, descriptions)
        all_errors.extend(f"Figure {figure.get('number')}: {error}" for error in errors)
    if all_errors:
        for error in all_errors:
            print(f"ERROR\t{error}")
        return 1

    args.output_dir.mkdir(parents=True, exist_ok=True)
    for figure in figures:
        output = args.output_dir / f"figure-{figure['number']}.svg"
        output.write_text(render(figure), encoding="utf-8")
        print(output)
        if args.png:
            try:
                import PIL
            except ImportError as error:
                raise SystemExit(
                    "PNG output requires Pillow: python -m pip install pillow"
                ) from error
            png_output = args.output_dir / f"figure-{figure['number']}.png"
            render_png(figure, png_output)
            print(png_output)
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

#!/usr/bin/env python3
"""Render a structured Chinese patent draft JSON file as DOCX."""

import argparse
import json
from pathlib import Path

from docx import Document
from docx.enum.section import WD_SECTION
from docx.enum.text import WD_ALIGN_PARAGRAPH
from docx.oxml import OxmlElement
from docx.oxml.ns import qn
from docx.shared import Cm, Pt

from math_to_omml import latex_to_omml


def set_run_font(run, name: str, size: float, bold: bool = False) -> None:
    run.font.name = name
    run.font.size = Pt(size)
    run.bold = bold
    run._element.rPr.rFonts.set(qn("w:eastAsia"), name)


def add_heading(document: Document, text: str, level: int = 1) -> None:
    paragraph = document.add_paragraph()
    paragraph.alignment = WD_ALIGN_PARAGRAPH.CENTER if level == 1 else WD_ALIGN_PARAGRAPH.LEFT
    run = paragraph.add_run(text)
    set_run_font(run, "宋体", 16 if level == 1 else 14, bold=True)


def add_body(document: Document, text: str, indent: bool = True) -> None:
    paragraph = document.add_paragraph()
    paragraph.paragraph_format.line_spacing = 1.5
    if indent:
        paragraph.paragraph_format.first_line_indent = Cm(0.74)
    run = paragraph.add_run(str(text))
    set_run_font(run, "宋体", 12)


def add_equation(document: Document, equation: dict) -> None:
    paragraph = document.add_paragraph()
    paragraph.alignment = WD_ALIGN_PARAGRAPH.CENTER
    paragraph.paragraph_format.space_before = Pt(6)
    paragraph.paragraph_format.space_after = Pt(6)
    latex = equation.get("latex")
    if not latex:
        raise ValueError(
            f"Equation {equation.get('number')} has no latex source for native Office Math"
        )
    paragraph._p.append(latex_to_omml(latex))
    number_run = paragraph.add_run(f"    ({equation.get('number', '')})")
    set_run_font(number_run, "Cambria Math", 12)
    description = equation.get("description")
    if description:
        add_body(document, description)


def add_page_number(section) -> None:
    paragraph = section.footer.paragraphs[0]
    paragraph.alignment = WD_ALIGN_PARAGRAPH.CENTER
    run = paragraph.add_run()
    begin = OxmlElement("w:fldChar")
    begin.set(qn("w:fldCharType"), "begin")
    instruction = OxmlElement("w:instrText")
    instruction.set(qn("xml:space"), "preserve")
    instruction.text = " PAGE "
    end = OxmlElement("w:fldChar")
    end.set(qn("w:fldCharType"), "end")
    run._r.extend((begin, instruction, end))


def configure(document: Document) -> None:
    section = document.sections[0]
    section.top_margin = Cm(2.54)
    section.bottom_margin = Cm(2.54)
    section.left_margin = Cm(3.17)
    section.right_margin = Cm(3.17)
    add_page_number(section)


def add_claims(document: Document, claims: list[dict]) -> None:
    add_heading(document, "权利要求书")
    for claim in claims:
        add_body(document, f"{claim['number']}. {claim['text']}", indent=False)


def add_specification(document: Document, data: dict, figure_dir: Path | None = None) -> None:
    add_heading(document, "说明书")
    add_heading(document, data.get("title", "[TO CONFIRM: title]"), level=2)
    spec = data.get("specification", {})
    sections = [
        ("技术领域", spec.get("technical_field", [])),
        ("背景技术", spec.get("background", [])),
    ]
    invention = spec.get("invention_content", {})
    sections.extend(
        [
            ("发明内容", invention.get("problem", []) + invention.get("solution", [])),
            ("有益效果", invention.get("beneficial_effects", [])),
            ("附图说明", spec.get("figure_descriptions", [])),
        ]
    )
    for heading, paragraphs in sections:
        add_heading(document, heading, level=2)
        for paragraph in paragraphs:
            add_body(document, paragraph)

    equations = spec.get("equations", [])
    if equations:
        add_heading(document, "公式及符号说明", level=2)
        for equation in equations:
            add_equation(document, equation)

    if figure_dir:
        figures = data.get("figures", [])
        if figures:
            add_heading(document, "说明书附图", level=2)
        for figure in figures:
            image = figure_dir / f"figure-{figure['number']}.png"
            if not image.exists():
                continue
            paragraph = document.add_paragraph()
            paragraph.alignment = WD_ALIGN_PARAGRAPH.CENTER
            run = paragraph.add_run()
            run.add_picture(str(image), width=Cm(14))
            caption = document.add_paragraph()
            caption.alignment = WD_ALIGN_PARAGRAPH.CENTER
            caption_run = caption.add_run(f"图{figure['number']} {figure.get('title', '')}")
            set_run_font(caption_run, "宋体", 11)

    add_heading(document, "具体实施方式", level=2)
    for embodiment in spec.get("embodiments", []):
        add_heading(document, embodiment.get("heading", "实施例"), level=2)
        for paragraph in embodiment.get("paragraphs", []):
            add_body(document, paragraph)


def add_figure(
    document: Document,
    figure: dict,
    figure_dir: Path | None,
    heading: str | None = None,
) -> bool:
    if not figure_dir:
        return False
    image = figure_dir / f"figure-{figure['number']}.png"
    if not image.exists():
        return False
    if heading:
        add_heading(document, heading, level=2)
    paragraph = document.add_paragraph()
    paragraph.alignment = WD_ALIGN_PARAGRAPH.CENTER
    run = paragraph.add_run()
    run.add_picture(str(image), width=Cm(14))
    caption = document.add_paragraph()
    caption.alignment = WD_ALIGN_PARAGRAPH.CENTER
    caption_run = caption.add_run(f"图{figure['number']} {figure.get('title', '')}")
    set_run_font(caption_run, "宋体", 11)
    return True


def abstract_figure(data: dict) -> dict | None:
    number = data.get("abstract_figure_number")
    return next(
        (figure for figure in data.get("figures", []) if figure.get("number") == number),
        None,
    )


def add_abstract(
    document: Document,
    data: dict,
    figure_dir: Path | None = None,
    include_figure: bool = True,
) -> None:
    add_heading(document, "说明书摘要")
    add_heading(document, data.get("title", "[TO CONFIRM: title]"), level=2)
    add_body(document, data.get("abstract", ""), indent=False)
    figure = abstract_figure(data)
    if include_figure and figure:
        add_figure(document, figure, figure_dir, heading="摘要附图")


def add_abstract_figure(
    document: Document,
    data: dict,
    figure_dir: Path | None,
) -> None:
    add_heading(document, "摘要附图")
    figure = abstract_figure(data)
    if figure:
        add_figure(document, figure, figure_dir)


def add_review_appendix(document: Document, data: dict) -> None:
    document.add_section(WD_SECTION.NEW_PAGE)
    add_heading(document, "起草审查附录")
    metadata = data.get("metadata", {})
    for key, value in metadata.items():
        add_body(document, f"{key}: {value}", indent=False)

    add_heading(document, "前提假设", level=2)
    for item in data.get("assumptions", []):
        add_body(document, f"- {item}", indent=False)

    concept = data.get("invention_concept", {})
    add_heading(document, "发明构思", level=2)
    for key in ("technical_problem", "technical_means", "technical_effect"):
        if concept.get(key):
            add_body(document, f"{key}: {concept[key]}", indent=False)

    ledger = data.get("evidence_ledger", [])
    if ledger:
        add_heading(document, "证据台账", level=2)
        table = document.add_table(rows=1, cols=6)
        table.style = "Table Grid"
        headers = ("ID", "技术特征", "来源位置", "技术作用", "效果", "支持状态")
        for cell, header in zip(table.rows[0].cells, headers):
            cell.text = header
        keys = ("id", "feature", "source_location", "technical_role", "effect", "support_status")
        for item in ledger:
            cells = table.add_row().cells
            for cell, key in zip(cells, keys):
                cell.text = str(item.get(key, ""))

    audit = data.get("audit", {})
    for heading, key in (
        ("支持性检查", "support_findings"),
        ("一致性检查", "consistency_findings"),
        ("发明人待确认问题", None),
    ):
        add_heading(document, heading, level=2)
        items = data.get("inventor_questions", []) if key is None else audit.get(key, [])
        for item in items:
            add_body(document, f"- {item}", indent=False)


def validate(data: dict) -> None:
    required = ("title", "claims", "specification", "abstract")
    missing = [key for key in required if key not in data]
    if missing:
        raise ValueError(f"Missing required keys: {', '.join(missing)}")
    numbers = [claim.get("number") for claim in data["claims"]]
    if numbers != list(range(1, len(numbers) + 1)):
        raise ValueError(f"Claim numbers must be consecutive integers starting at 1: {numbers}")


def main() -> int:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("draft", type=Path, help="UTF-8 JSON draft")
    parser.add_argument("--output", type=Path, required=True, help="Output DOCX path")
    parser.add_argument(
        "--part",
        choices=("all", "claims", "specification", "abstract", "abstract-figure"),
        default="all",
        help="Document part to render",
    )
    parser.add_argument(
        "--figure-dir",
        type=Path,
        help="Directory containing figure-N.png images for the specification",
    )
    args = parser.parse_args()

    data = json.loads(args.draft.read_text(encoding="utf-8"))
    validate(data)
    document = Document()
    configure(document)
    if args.part == "claims":
        add_claims(document, data["claims"])
    elif args.part == "specification":
        add_specification(document, data, args.figure_dir)
    elif args.part == "abstract":
        add_abstract(document, data, args.figure_dir)
    elif args.part == "abstract-figure":
        add_abstract_figure(document, data, args.figure_dir)
    else:
        add_claims(document, data["claims"])
        document.add_page_break()
        add_specification(document, data, args.figure_dir)
        document.add_page_break()
        add_abstract(document, data, args.figure_dir)
        add_review_appendix(document, data)
    args.output.parent.mkdir(parents=True, exist_ok=True)
    document.save(args.output)
    print(args.output)
    return 0


if __name__ == "__main__":
    raise SystemExit(main())