python-hwpx-automation 7.3.3__tar.gz → 7.4.0__tar.gz

{python_hwpx_automation-7.3.3/src/python_hwpx_automation.egg-info → python_hwpx_automation-7.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-hwpx-automation
-Version: 7.3.3
+Version: 7.4.0
 Summary: Task-oriented HWPX document automation for Python, with an optional MCP adapter.
 Author: Kohkyuhyun
 License-Expression: Apache-2.0
@@ -74,7 +74,7 @@ Dynamic: license-file
 
 <!-- release-state: release-approved -->
 > [!NOTE]
-> 발행이 승인된 7.3.3 후보 (release-approved; 원격 발행 대기): `python-hwpx 6.6.0 → python-hwpx-automation 7.3.3 → hwpx-plugin 2.4.0` (`5e5c23651f92785a`).
+> 발행이 승인된 7.4.0 후보 (release-approved; 원격 발행 대기): `python-hwpx 6.6.0 → python-hwpx-automation 7.4.0 → hwpx-plugin 2.4.0` (`5e5c23651f92785a`).
 > 공개 트레인: `python-hwpx 6.6.0 → python-hwpx-automation 7.3.1 → hwpx-plugin 2.4.0`.
 > 공개 좌표는 core·automation PyPI와 plugin GitHub
 > Release·marketplace·실제 marketplace 설치 관찰 후에만 승격합니다.
@@ -162,7 +162,7 @@ PDF와 쪽 PNG로 렌더합니다. 별도 환경에서 실행하므로 호출하
 고정 버전을 건드리지 않습니다.
 
 ```bash
-uvx --from "python-hwpx-automation[oracle]==7.3.3" \
+uvx --from "python-hwpx-automation[oracle]==7.4.0" \
   hwpx render-pdf in.hwpx out.pdf --png out/page --json
 ```
 

{python_hwpx_automation-7.3.3 → python_hwpx_automation-7.4.0}/README.md

@@ -14,7 +14,7 @@
 
 <!-- release-state: release-approved -->
 > [!NOTE]
-> 발행이 승인된 7.3.3 후보 (release-approved; 원격 발행 대기): `python-hwpx 6.6.0 → python-hwpx-automation 7.3.3 → hwpx-plugin 2.4.0` (`5e5c23651f92785a`).
+> 발행이 승인된 7.4.0 후보 (release-approved; 원격 발행 대기): `python-hwpx 6.6.0 → python-hwpx-automation 7.4.0 → hwpx-plugin 2.4.0` (`5e5c23651f92785a`).
 > 공개 트레인: `python-hwpx 6.6.0 → python-hwpx-automation 7.3.1 → hwpx-plugin 2.4.0`.
 > 공개 좌표는 core·automation PyPI와 plugin GitHub
 > Release·marketplace·실제 marketplace 설치 관찰 후에만 승격합니다.
@@ -102,7 +102,7 @@ PDF와 쪽 PNG로 렌더합니다. 별도 환경에서 실행하므로 호출하
 고정 버전을 건드리지 않습니다.
 
 ```bash
-uvx --from "python-hwpx-automation[oracle]==7.3.3" \
+uvx --from "python-hwpx-automation[oracle]==7.4.0" \
   hwpx render-pdf in.hwpx out.pdf --png out/page --json
 ```
 

{python_hwpx_automation-7.3.3 → python_hwpx_automation-7.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-hwpx-automation"
-version = "7.3.3"
+version = "7.4.0"
 description = "Task-oriented HWPX document automation for Python, with an optional MCP adapter."
 readme = "README.md"
 authors = [{ name = "Kohkyuhyun" }]

{python_hwpx_automation-7.3.3 → python_hwpx_automation-7.4.0}/src/hwpx_automation/core/search.py

@@ -93,11 +93,16 @@ def _replace_in_runs(runs: list[Any], find_text: str, replace_text: str) -> int:
     if not runs:
         return 0
 
-    replaced = _replace_within_runs(runs, find_text, replace_text)
-    merged_after_simple = "".join(run.text or "" for run in runs)
-    if find_text in merged_after_simple:
-        replaced += _replace_across_runs(runs, find_text, replace_text)
-    return replaced
+    # Decide from the text before any replacement: re-scanning afterwards would find
+    # find_text again inside replace_text when the one contains the other.
+    if not _has_match_across_runs([run.text or "" for run in runs], find_text):
+        return _replace_within_runs(runs, find_text, replace_text)
+    return _replace_across_runs(runs, find_text, replace_text)
+
+
+def _has_match_across_runs(texts: list[str], find_text: str) -> bool:
+    """Whether some occurrence of *find_text* in the joined text spans two runs."""
+    return "".join(texts).count(find_text) != sum(text.count(find_text) for text in texts)
 
 
 def _replace_within_xml_runs(run_elements: list[Any], find_text: str, replace_text: str) -> int:
@@ -134,11 +139,9 @@ def _replace_in_xml_runs(run_elements: list[Any], find_text: str, replace_text:
     if not run_elements:
         return 0
 
-    replaced = _replace_within_xml_runs(run_elements, find_text, replace_text)
-    merged_after_simple = "".join(_xml_run_text(run_element) for run_element in run_elements)
-    if find_text in merged_after_simple:
-        replaced += _replace_across_xml_runs(run_elements, find_text, replace_text)
-    return replaced
+    if not _has_match_across_runs([_xml_run_text(run_element) for run_element in run_elements], find_text):
+        return _replace_within_xml_runs(run_elements, find_text, replace_text)
+    return _replace_across_xml_runs(run_elements, find_text, replace_text)
 
 
 def find_in_doc(doc: Any, text_to_find: str, match_case: bool = True, max_results: int = 50) -> dict:

{python_hwpx_automation-7.3.3 → python_hwpx_automation-7.4.0}/src/hwpx_automation/identity.json

@@ -7,9 +7,9 @@
     "candidate": {
       "pythonHwpx": "6.6.0",
       "canonicalDistribution": "python-hwpx-automation",
-      "canonicalAutomation": "7.3.3",
+      "canonicalAutomation": "7.4.0",
       "compatibilityDistribution": "hwpx-mcp-server",
-      "compatibility": "7.3.3",
+      "compatibility": "7.4.0",
       "plugin": "2.4.0",
       "contractHash": "5e5c23651f92785a"
     },

{python_hwpx_automation-7.3.3 → python_hwpx_automation-7.4.0}/src/hwpx_automation/office/agent/commands.py

@@ -438,6 +438,32 @@ def _insert_direct_child(
         container.insert(list(container).index(siblings[index]), element)
 
 
+def _drop_layout_cache(paragraph_element: Any | None) -> None:
+    """Remove a paragraph's line layout cache (``hp:linesegarray``) after its content changed.
+
+    The cache records where each line starts in the paragraph's content. Once an object or a run has left or
+    joined the paragraph, the cache no longer matches: Hancom reports a document whose cached lines point past
+    the remaining content as damaged, while without the cache it lays the paragraph out again. Only the
+    paragraph that changed is touched; every other paragraph keeps the cache Hancom wrote. ``None`` (an
+    element no paragraph holds) changes nothing.
+    """
+
+    if paragraph_element is None:
+        return
+    for child in list(paragraph_element):
+        if _local_name(child).lower() == "linesegarray":
+            paragraph_element.remove(child)
+
+
+def _paragraph_element_of(element: Any) -> Any | None:
+    """The nearest ``hp:p`` holding *element*, or ``None`` when it is detached."""
+
+    current = element
+    while current is not None and _local_name(current) != "p":
+        current = current.getparent() if hasattr(current, "getparent") else None
+    return current
+
+
 def _insert_inline(
     view: HwpxAgentDocument,
     parent: NodeRecord,
@@ -468,6 +494,7 @@ def _insert_inline(
         if _local_name(anchor_run) == "ctrl":
             anchor_run = anchor_run.getparent()
         paragraph.element.insert(list(paragraph.element).index(anchor_run), run)
+    _drop_layout_cache(paragraph.element)
     paragraph.section.mark_dirty()
     return run
 
@@ -482,6 +509,7 @@ def _remove_inline_element(element: Any, paragraph: Any) -> None:
         run.remove(control)
     if not list(run) and run in list(paragraph.element):
         paragraph.element.remove(run)
+    _drop_layout_cache(paragraph.element)
     paragraph.section.mark_dirty()
 
 
@@ -834,7 +862,8 @@ def _add(
         if position["mode"] != "append":
             parent.native.element.remove(created.element)
             _insert_direct_child(view, parent, kind, created.element, position)
-            parent.native.section.mark_dirty()
+        _drop_layout_cache(parent.native.element)
+        parent.native.section.mark_dirty()
         return created
     if kind == "table":
         created = parent.native.add_table(
@@ -896,7 +925,9 @@ def _remove(document: HwpxDocument, record: NodeRecord) -> None:
     if record.kind == "paragraph":
         native.remove()
     elif record.kind == "run":
+        paragraph_element = native.paragraph.element
         native.remove()
+        _drop_layout_cache(paragraph_element)
     elif record.kind == "table":
         _remove_inline_element(native.element, native.paragraph)
     elif record.kind == "row":
@@ -914,6 +945,7 @@ def _remove(document: HwpxDocument, record: NodeRecord) -> None:
         if parent is None:
             raise AgentContractError("not_found", "picture is detached", target=record.path)
         parent.remove(_element(record.native))
+        _drop_layout_cache(_paragraph_element_of(parent))
         _mark_containing_section(document, parent)
     elif record.kind == "shape":
         _remove_inline_element(native.element, native.paragraph)
@@ -934,6 +966,7 @@ def _detach(view: HwpxAgentDocument, record: NodeRecord) -> Any:
         record.native.section.mark_dirty()
     elif record.kind == "run":
         record.native.paragraph.element.remove(element)
+        _drop_layout_cache(record.native.paragraph.element)
         record.native.paragraph.section.mark_dirty()
     elif record.kind in _INLINE_KINDS:
         paragraph = record.native.paragraph if hasattr(record.native, "paragraph") else None
@@ -1002,6 +1035,7 @@ def _move(
         if source.kind == "paragraph":
             parent.native.mark_dirty()
         elif source.kind == "run":
+            _drop_layout_cache(parent.native.element)
             parent.native.section.mark_dirty()
         else:
             _refresh_table_rows(source.native.table)
@@ -1157,6 +1191,7 @@ def _copy_node(
         if source.kind == "paragraph":
             parent.native.mark_dirty()
         elif source.kind == "run":
+            _drop_layout_cache(parent.native.element)
             parent.native.section.mark_dirty()
         else:
             _refresh_table_rows(parent.native)

{python_hwpx_automation-7.3.3 → python_hwpx_automation-7.4.0}/src/hwpx_automation/office/authoring/design/composer.py

@@ -22,6 +22,7 @@ from hwpx.document import HwpxDocument
 from hwpx.quality import QualityPolicy
 
 import hwpx_automation.office.authoring.design._support as S
+from .marked import OBJECT_TAGS, fill_placeholders, fragment_paragraphs, is_marked_profile
 from .plan import Block, DocumentPlan
 from .profile import Profile, load_profile
 from .validator import StyleCoverage, style_coverage
@@ -82,7 +83,11 @@ def compose(
         secpr = deepcopy(secpr)
 
         new_paragraphs: list[etree._Element] = []
+        marked = is_marked_profile(prof.manifest)
         for block in plan.iter_blocks():
+            if marked:
+                new_paragraphs.extend(_marked_fragment_for(prof, block, production, warnings))
+                continue
             frag = _fragment_for(prof, block, production, warnings)
             if frag is None:
                 continue
@@ -96,6 +101,7 @@ def compose(
         S.move_secpr_into(new_paragraphs[0], secpr)
         S.replace_section_body(section.element, new_paragraphs)
         _reassign_paragraph_ids(new_paragraphs)
+        _reassign_object_ids(new_paragraphs)
         section.mark_dirty()
 
         coverage = style_coverage(doc, new_paragraphs)
@@ -188,6 +194,35 @@ def _fragment_for(
     return frag
 
 
+def _marked_fragment_for(
+    prof: Profile, block: Block, production: bool, warnings: list[str]
+) -> list[etree._Element]:
+    """Clone the author-named role and fill its slots (marked-template profiles)."""
+
+    if not prof.has_role(block.role):
+        _forbid_fallback(
+            production, f"marked profile {prof.id!r} has no role {block.role!r}", warnings
+        )
+        return []
+    values = dict(block.values)
+    slots = prof.manifest.get("slots", {}).get(block.role, [])
+    # Plain ``text`` fills the unnamed slot, or the only slot a role has.
+    if block.text and "" in slots and "" not in values:
+        values[""] = block.text
+    elif block.text and len(slots) == 1 and slots[0] not in values:
+        values[slots[0]] = block.text
+    paragraphs = fragment_paragraphs(prof.fragment(block.role))
+    unfilled = fill_placeholders(paragraphs, block.role, values)
+    if not values:
+        # A block with no text and no values asks for the role as is (a page
+        # break line, a separator) -- blank slots are what it wants.
+        return paragraphs
+    for slot in unfilled:
+        name = f"{block.role}.{slot}" if slot else block.role
+        warnings.append(f"MARKED_SLOT_EMPTY: no value for {{{{{name}}}}}; left blank")
+    return paragraphs
+
+
 def _forbid_fallback(production: bool, message: str, warnings: list[str]) -> None:
     if production:
         raise ProfileRequiredError("PROFILE_REQUIRED: " + message)
@@ -279,4 +314,20 @@ def _reassign_paragraph_ids(paragraphs: list[etree._Element]) -> None:
                 para.set("id", str(uuid4().int % (2**31)))
 
 
+# Composed bodies are made only of clones, so object ids restart from a fixed
+# base — deterministic output, and no clone shares the id of another.
+_OBJECT_ID_BASE = 1_000_000_000
+
+
+def _reassign_object_ids(paragraphs: list[etree._Element]) -> None:
+    """Give every table/drawing object a unique id (fragments may repeat)."""
+
+    next_id = _OBJECT_ID_BASE
+    for root in paragraphs:
+        for element in root.iter():
+            if S.ln(element.tag) in OBJECT_TAGS and element.get("id") is not None:
+                element.set("id", str(next_id))
+                next_id += 1
+
+
 __all__ = ["compose", "compose_bytes", "ComposeResult", "ProfileRequiredError"]

{python_hwpx_automation-7.3.3 → python_hwpx_automation-7.4.0}/src/hwpx_automation/office/authoring/design/harvest.py

@@ -3,8 +3,8 @@
 
 Given a genuine ``.hwpx`` it writes, under ``profiles/<id>/``:
 
-* ``template.hwpx`` — a **body-stripped skeleton**: the real document with its
-  section body reduced to a single ``secPr``-carrying paragraph. ``header.xml``
+* ``template.hwpx`` — a **body-stripped skeleton**: the real document reduced to
+  its first section, whose body is a single ``secPr``-carrying paragraph. ``header.xml``
   (every style/font/borderFill) and the page setup survive untouched, so the
   committed artifact is small and carries no document content (no PII), yet is
   genuinely Hancom-derived — never imagined XML.
@@ -160,6 +160,9 @@ def _subList(tc: etree._Element):
 
 def _build_skeleton(source: Path, out_path: Path) -> dict:
     doc = HwpxDocument.open(source)
+    # Only the first section's page setup is reused; later sections would ride
+    # into every composed document with the source's text.
+    _drop_later_sections(doc)
     section = doc.sections[0]
     secpr = S.find_secpr(section.element)
     if secpr is None:
@@ -199,6 +202,26 @@ def _build_skeleton(source: Path, out_path: Path) -> dict:
     }
 
 
+def _drop_later_sections(doc) -> None:
+    """Remove every section after the first, part and manifest item included.
+
+    Older cores remove the section from the document tree but keep its part,
+    which would still be saved with the source text in it.
+    """
+
+    dropped = [section.part_name for section in doc.sections[1:]]
+    for extra in reversed(doc.sections[1:]):
+        doc.remove_section(extra)
+    package = doc._package
+    for item in list(package._manifest_items()):
+        href = item.get("href", "") or ""
+        if any(name.endswith(href) for name in dropped if href) and item.get("id"):
+            package.remove_manifest_item(item.get("id"))
+    for name in dropped:
+        if package.has_part(name):
+            package.delete(name)
+
+
 def _strip_binaries(doc) -> list[str]:
     """Drop embedded images + the source preview (size + PII) from the skeleton.
 
@@ -209,6 +232,10 @@ def _strip_binaries(doc) -> list[str]:
 
     package = doc._package
     removed: list[str] = []
+    # Image fills defined in header.xml (borderFill imgBrush) are styles, not
+    # body content: dropping their binaries would leave dangling references.
+    kept_ids = _header_binary_refs(package)
+    kept_parts: set[str] = set()
 
     for item in list(package._manifest_items()):
         href = item.get("href", "") or ""
@@ -220,10 +247,15 @@ def _strip_binaries(doc) -> list[str]:
             or media.lower().startswith("image/")
         ):
             item_id = item.get("id")
+            if item_id in kept_ids:
+                kept_parts.add(href)
+                continue
             if item_id:
                 package.remove_manifest_item(item_id)
 
     for name in list(package.part_names()):
+        if any(name.endswith(href) for href in kept_parts):
+            continue
         if name.startswith("BinData/") or name.startswith("Preview/PrvImage"):
             try:
                 package.delete(name)
@@ -236,6 +268,16 @@ def _strip_binaries(doc) -> list[str]:
     return removed
 
 
+def _header_binary_refs(package) -> set[str]:
+    refs: set[str] = set()
+    for path in package.header_paths():
+        for node in package.get_xml(path).iter():
+            for key, value in node.attrib.items():
+                if S.ln(key) == "binaryItemIDRef":
+                    refs.add(value)
+    return refs
+
+
 # Manifest (content.hpf) metadata that carries source PII — author, the person who
 # last saved, the source title, and timestamps. Cleared so generated docs inherit
 # nothing identifying.

python_hwpx_automation-7.4.0/src/hwpx_automation/office/authoring/design/marked.py

@@ -0,0 +1,273 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Marked-template profiles — fragments named by the template author.
+
+:func:`~hwpx_automation.office.authoring.design.harvest.harvest_profile` guesses
+roles from font size and keeps a single info table, so it cannot tell a coloured
+chapter-band table from a data table, or one bullet level from another. Here the
+author decides instead: in a Hancom-saved template they type placeholders where
+content goes —
+
+* ``□ {{1단계}}`` — a paragraph role ``1단계`` with one unnamed slot;
+* ``{{띠.번호}}`` / ``{{띠.제목}}`` in the cells of a band table — a role ``띠``
+  with the slots ``번호`` and ``제목``.
+
+Every top-level paragraph that carries placeholders becomes one role. Text-less
+paragraphs directly above it (the spacer lines Hancom users put between items)
+belong to the same role, so spacing is cloned with it. Fills, borders, fonts and
+indents are never interpreted: the composer clones the saved XML and swaps only
+the placeholder text.
+"""
+from __future__ import annotations
+
+import json
+import re
+from copy import deepcopy
+from pathlib import Path
+from typing import Mapping
+
+from lxml import etree  # pyright: ignore[reportAttributeAccessIssue]
+
+from hwpx.document import HwpxDocument
+
+import hwpx_automation.office.authoring.design._support as S
+from .harvest import PROFILE_SCHEMA, _build_skeleton, _references_binary
+
+MARKED_PROFILE_KIND = "marked"
+# Wrapper for a multi-paragraph fragment file; never written into a document.
+FRAGMENT_WRAPPER_TAG = "fragment"
+
+PLACEHOLDER_RE = re.compile(r"\{\{\s*([^{}.\s]+)(?:\.([^{}\s]+))?\s*\}\}")
+
+# Objects whose ``id`` must stay unique when a fragment is cloned more than once.
+OBJECT_TAGS = frozenset(
+    {
+        "tbl", "pic", "rect", "ellipse", "arc", "polygon", "curve", "line",
+        "connectLine", "container", "ole", "equation", "textart",
+    }
+)
+
+
+class MarkedTemplateError(ValueError):
+    """The template's placeholders cannot be turned into a profile."""
+
+
+def is_marked_profile(manifest: Mapping[str, object]) -> bool:
+    return manifest.get("kind") == MARKED_PROFILE_KIND
+
+
+def _text_pieces(element: etree._Element) -> list[tuple[etree._Element, str]]:
+    """(owner, attr) pairs for every text piece of every ``<hp:t>`` under *element*.
+
+    ``attr`` is ``"text"`` for ``t.text`` and ``"tail"`` for the tail of an inline
+    child (tab, line break) inside the ``<hp:t>``.
+    """
+
+    pieces: list[tuple[etree._Element, str]] = []
+    for t in S.iter_local(element, "t"):
+        pieces.append((t, "text"))
+        for child in t:
+            pieces.append((child, "tail"))
+    return pieces
+
+
+def _get(piece: tuple[etree._Element, str]) -> str:
+    owner, attr = piece
+    return (owner.text if attr == "text" else owner.tail) or ""
+
+
+def _set(piece: tuple[etree._Element, str], value: str) -> None:
+    owner, attr = piece
+    if attr == "text":
+        owner.text = value
+    else:
+        owner.tail = value
+
+
+def placeholders_in(element: etree._Element) -> list[tuple[str, str]]:
+    """(role, slot) for every placeholder under *element*; slot ``""`` if unnamed."""
+
+    found: list[tuple[str, str]] = []
+    for para in S.iter_local(element, "p"):
+        joined = "".join(_get(p) for p in _direct_pieces(para))
+        found.extend((m.group(1), m.group(2) or "") for m in PLACEHOLDER_RE.finditer(joined))
+    return list(dict.fromkeys(found))
+
+
+def _direct_pieces(paragraph: etree._Element) -> list[tuple[etree._Element, str]]:
+    """Text pieces of *paragraph* itself, excluding paragraphs nested in its tables."""
+
+    pieces: list[tuple[etree._Element, str]] = []
+    for run in S.children_local(paragraph, "run"):
+        for t in S.children_local(run, "t"):
+            pieces.append((t, "text"))
+            for child in t:
+                pieces.append((child, "tail"))
+    return pieces
+
+
+def _is_blank(paragraph: etree._Element) -> bool:
+    if any(_get(p).strip() for p in _text_pieces(paragraph)):
+        return False
+    for node in paragraph.iter():
+        if S.ln(node.tag) in OBJECT_TAGS:
+            return False
+    return True
+
+
+def _strip_section_setup(fragment: etree._Element) -> None:
+    """Drop the page setup a template's first paragraph carries (secPr + colPr ctrl)."""
+
+    for run in S.children_local(fragment, "run"):
+        for secpr in S.children_local(run, "secPr"):
+            run.remove(secpr)
+        for ctrl in S.children_local(run, "ctrl"):
+            if any(S.ln(c.tag) == "colPr" for c in ctrl):
+                run.remove(ctrl)
+
+
+def fill_placeholders(
+    paragraphs: list[etree._Element], role: str, values: Mapping[str, str]
+) -> list[str]:
+    """Replace ``{{role}}``/``{{role.slot}}`` text in place; return unfilled slots.
+
+    A placeholder inside one text piece keeps that piece's run (and its style).
+    One that Hancom split across runs is rebuilt in the paragraph's first piece.
+    Missing values become empty text so a placeholder never ships.
+    """
+
+    unfilled: list[str] = []
+
+    def replace(match: re.Match[str]) -> str:
+        if match.group(1) != role:
+            return match.group(0)
+        slot = match.group(2) or ""
+        if slot not in values:
+            unfilled.append(slot)
+            return ""
+        return str(values[slot])
+
+    for root in paragraphs:
+        for para in S.iter_local(root, "p"):
+            pieces = _direct_pieces(para)
+            for piece in pieces:
+                text = _get(piece)
+                if "{{" in text:
+                    _set(piece, PLACEHOLDER_RE.sub(replace, text))
+            joined = "".join(_get(p) for p in pieces)
+            if any(m.group(1) == role for m in PLACEHOLDER_RE.finditer(joined)):
+                _set(pieces[0], PLACEHOLDER_RE.sub(replace, joined))
+                for piece in pieces[1:]:
+                    _set(piece, "")
+        S.strip_lineseg(root)
+    return list(dict.fromkeys(unfilled))
+
+
+def _pick_marked_fragments(
+    section_element: etree._Element,
+) -> tuple[dict[str, list[etree._Element]], dict[str, list[str]], int]:
+    fragments: dict[str, list[etree._Element]] = {}
+    slots: dict[str, list[str]] = {}
+    pending: list[etree._Element] = []
+    ignored = 0
+    for para in S.children_local(section_element, "p"):
+        marks = placeholders_in(para)
+        if not marks:
+            if _is_blank(para):
+                pending.append(para)
+            else:
+                ignored += 1  # static content outside any role
+                pending = []
+            continue
+        roles = list(dict.fromkeys(role for role, _ in marks))
+        if len(roles) > 1:
+            raise MarkedTemplateError(
+                f"one paragraph carries placeholders of several roles {roles}; "
+                "put each role in its own paragraph or table"
+            )
+        role = roles[0]
+        if role in fragments:
+            raise MarkedTemplateError(f"role {role!r} appears more than once in the template")
+        group = [deepcopy(p) for p in (*pending, para)]
+        pending = []
+        for frag in group:
+            if _references_binary(frag):
+                raise MarkedTemplateError(
+                    f"role {role!r} contains an image or embedded object; "
+                    "fragments must be text, tables and shapes only"
+                )
+            _strip_section_setup(frag)
+            S.strip_lineseg(frag)
+        fragments[role] = group
+        slots[role] = [slot for _, slot in marks]
+    if not fragments:
+        raise MarkedTemplateError("template has no {{placeholder}} paragraphs")
+    return fragments, slots, ignored
+
+
+def harvest_marked_profile(source: str | Path, profile_id: str, out_root: str | Path) -> dict:
+    """Harvest a placeholder-marked template into ``<out_root>/<profile_id>/``.
+
+    Only the first section is read. Returns the written manifest plus
+    ``skeleton_open_safe`` and ``stripped_parts`` diagnostics.
+    """
+
+    source = Path(source)
+    out_dir = Path(out_root) / profile_id
+    (out_dir / "fragments").mkdir(parents=True, exist_ok=True)
+
+    doc = HwpxDocument.open(source)
+    try:
+        fragments, slots, ignored = _pick_marked_fragments(doc.sections[0].element)
+    finally:
+        doc.close()
+
+    paths: dict[str, str] = {}
+    for index, (role, group) in enumerate(fragments.items()):
+        wrapper = etree.Element(FRAGMENT_WRAPPER_TAG)
+        wrapper.extend(group)
+        rel = f"fragments/{index:02d}.xml"
+        (out_dir / rel).write_bytes(etree.tostring(wrapper, encoding="UTF-8"))
+        paths[role] = rel
+
+    skel = _build_skeleton(source, out_dir / "template.hwpx")
+    manifest = {
+        "schemaVersion": PROFILE_SCHEMA,
+        "kind": MARKED_PROFILE_KIND,
+        "id": profile_id,
+        "template": "template.hwpx",
+        "fragments": paths,
+        "slots": slots,
+        "page": skel["page"],
+        "char_pr_count": skel["char_pr_count"],
+        "style_coverage_threshold": 0.98,
+        "source_basename": source.name,
+        "ignored_static_paragraphs": ignored,
+    }
+    (out_dir / "profile.json").write_text(
+        json.dumps(manifest, ensure_ascii=False, indent=2), encoding="utf-8"
+    )
+    return {
+        **manifest,
+        "skeleton_open_safe": skel["open_safe"],
+        "stripped_parts": skel.get("stripped_parts", []),
+    }
+
+
+def fragment_paragraphs(fragment: etree._Element) -> list[etree._Element]:
+    """The ``<hp:p>`` list a (possibly wrapped) fragment element stands for."""
+
+    if fragment.tag == FRAGMENT_WRAPPER_TAG:
+        return list(fragment)
+    return [fragment]
+
+
+__all__ = [
+    "MARKED_PROFILE_KIND",
+    "PLACEHOLDER_RE",
+    "MarkedTemplateError",
+    "harvest_marked_profile",
+    "fill_placeholders",
+    "placeholders_in",
+    "fragment_paragraphs",
+    "is_marked_profile",
+]

{python_hwpx_automation-7.3.3 → python_hwpx_automation-7.4.0}/src/hwpx_automation/office/authoring/design/plan.py

@@ -26,6 +26,8 @@ class Block:
     text: str = ""
     columns: list[str] = field(default_factory=list)
     rows: list[list[str]] = field(default_factory=list)
+    #: Slot values for a marked-template role (``{{role.slot}}`` → value).
+    values: dict[str, str] = field(default_factory=dict)
 
     @classmethod
     def from_dict(cls, data: dict[str, Any]) -> "Block":
@@ -35,6 +37,7 @@ class Block:
             text=str(data.get("text", "")),
             columns=[str(c) for c in data.get("columns", [])],
             rows=[[str(c) for c in row] for row in data.get("rows", [])],
+            values={str(k): str(v) for k, v in (data.get("values") or {}).items()},
         )